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

package/src/domain/logger/loggerCollection.ts

@@ -0,0 +1,69 @@
+import { timeStampNow } from '@kubesense/kubesense-js-core/time'
+import type { TimeStamp } from '@kubesense/kubesense-js-core/time'
+import type { Context } from '@kubesense/kubesense-browser-core'
+import { ErrorSource } from '@kubesense/kubesense-browser-core'
+import { originalConsoleMethods, globalConsole, ConsoleApiName, combine } from '@kubesense/kubesense-js-core/util'
+import type { CommonContext, RawLogsEvent } from '../../rawLogsEvent.types'
+import type { LifeCycle, RawLogsEventCollectedData } from '../lifeCycle'
+import { LifeCycleEventType } from '../lifeCycle'
+import type { Logger, LogsMessage } from '../logger'
+import { HandlerType } from '../logger'
+import { isAuthorized, StatusType } from './isAuthorized'
+
+export function startLoggerCollection(lifeCycle: LifeCycle) {
+  function handleLog(
+    logsMessage: LogsMessage,
+    logger: Logger,
+    handlingStack?: string,
+    savedCommonContext?: CommonContext,
+    savedDate?: TimeStamp
+  ) {
+    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: RawLogsEventCollectedData<RawLogsEvent> = {
+        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(LifeCycleEventType.RAW_LOG_COLLECTED, rawLogEventData)
+    }
+  }
+
+  return {
+    handleLog,
+  }
+}
+const loggerToConsoleApiName: { [key in StatusType]: ConsoleApiName } = {
+  [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 }: LogsMessage, messageContext: Context | undefined) {
+  originalConsoleMethods[loggerToConsoleApiName[status]].call(globalConsole, message, messageContext)
+}

package/src/domain/logger.ts

@@ -0,0 +1,202 @@
+import type { Context, ContextManager, DebugIdEntry } from '@kubesense/kubesense-browser-core'
+import { clocksNow } from '@kubesense/kubesense-js-core/time'
+import { combine } from '@kubesense/kubesense-js-core/util'
+import {
+  computeRawError,
+  ErrorHandling,
+  createContextManager,
+  ErrorSource,
+  sanitize,
+  NonErrorPrefix,
+  createHandlingStack,
+  buildTag,
+  sanitizeTag,
+} from '@kubesense/kubesense-browser-core'
+import { callMonitored } from '@kubesense/kubesense-js-core/monitor'
+
+import { isAuthorized, StatusType } from './logger/isAuthorized'
+import { createErrorFieldFromRawError } from './createErrorFieldFromRawError'
+
+export interface LogsMessage {
+  message: string
+  status: StatusType
+  context?: Context
+  debugIds?: DebugIdEntry[]
+}
+
+export const HandlerType = {
+  console: 'console',
+  http: 'http',
+  silent: 'silent',
+} as const
+
+export type HandlerType = (typeof HandlerType)[keyof typeof HandlerType]
+export const STATUSES = Object.keys(StatusType) as StatusType[]
+
+// note: it is safe to merge declarations as long as the methods are actually defined on the prototype
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging, no-restricted-syntax
+export class Logger {
+  private contextManager: ContextManager
+
+  // Tags are formatted as either `key:value` or `key_only`
+  private tags: string[]
+
+  constructor(
+    private handleLogStrategy: (logsMessage: LogsMessage, logger: Logger, handlingStack?: string) => void,
+    name?: string,
+    private handlerType: HandlerType | HandlerType[] = HandlerType.http,
+    private level: StatusType = StatusType.debug,
+    loggerContext: object = {}
+  ) {
+    this.contextManager = createContextManager('logger')
+    this.tags = []
+    this.contextManager.setContext(loggerContext)
+    if (name) {
+      this.contextManager.setContextProperty('logger', { name })
+    }
+  }
+
+  logImplementation(
+    message: string,
+    messageContext?: object,
+    status: StatusType = StatusType.info,
+    error?: Error,
+    handlingStack?: string
+  ) {
+    callMonitored(() => {
+      const sanitizedMessageContext = sanitize(messageContext) as Context
+      let context: Context
+      let debugIds: DebugIdEntry[] | undefined
+
+      if (error !== undefined && 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: string, messageContext?: object, status: StatusType = StatusType.info, error?: Error) {
+    let handlingStack: string | undefined
+
+    if (isAuthorized(status, HandlerType.http, this)) {
+      handlingStack = createHandlingStack('log')
+    }
+
+    this.logImplementation(message, messageContext, status, error, handlingStack)
+  }
+
+  setContext(context: object) {
+    this.contextManager.setContext(context)
+  }
+
+  getContext() {
+    return this.contextManager.getContext()
+  }
+
+  setContextProperty(key: string, value: any) {
+    this.contextManager.setContextProperty(key, value)
+  }
+
+  removeContextProperty(key: string) {
+    this.contextManager.removeContextProperty(key)
+  }
+
+  clearContext() {
+    this.contextManager.clearContext()
+  }
+
+  addTag(key: string, value?: string) {
+    this.tags.push(buildTag(key, value))
+  }
+
+  removeTagsWithKey(key: string) {
+    const sanitizedKey = sanitizeTag(key)
+
+    this.tags = this.tags.filter((tag) => tag !== sanitizedKey && !tag.startsWith(`${sanitizedKey}:`))
+  }
+
+  getTags() {
+    return this.tags.slice()
+  }
+
+  setHandler(handler: HandlerType | HandlerType[]) {
+    this.handlerType = handler
+  }
+
+  getHandler() {
+    return this.handlerType
+  }
+
+  setLevel(level: StatusType) {
+    this.level = level
+  }
+
+  getLevel() {
+    return this.level
+  }
+}
+
+/* eslint-disable local-rules/disallow-side-effects */
+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)
+/* eslint-enable local-rules/disallow-side-effects */
+
+// note: it is safe to merge declarations as long as the methods are actually defined on the prototype
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
+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
+}
+
+function createLoggerMethod(status: StatusType) {
+  return function (this: Logger, message: string, messageContext?: object, error?: Error) {
+    let handlingStack: string | undefined
+
+    if (isAuthorized(status, HandlerType.http, this)) {
+      handlingStack = createHandlingStack('log')
+    }
+
+    this.logImplementation(message, messageContext, status, error, handlingStack)
+  }
+}

package/src/domain/networkError/networkErrorCollection.ts

@@ -0,0 +1,104 @@
+import type {
+  FetchResolveContext,
+  XhrCompleteContext,
+  Observable,
+  BufferedData,
+} from '@kubesense/kubesense-browser-core'
+import {
+  BufferedDataType,
+  ErrorSource,
+  RequestType,
+  initFetchObservable,
+  computeStackTrace,
+  toStackTraceString,
+  noop,
+  isServerError,
+  ResponseBodyAction,
+  safeTruncate,
+  ONE_KIBI_BYTE,
+  buildDebugIdByUrl,
+  getStackTraceUrls,
+} from '@kubesense/kubesense-browser-core'
+import { isIntakeUrl } from '@kubesense/kubesense-js-core/transport'
+import type { LogsConfiguration } from '../configuration'
+
+/** arbitrary value, byte precision not needed */
+export const DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT = 32 * ONE_KIBI_BYTE
+import type { LifeCycle } from '../lifeCycle'
+import type { LogsEventDomainContext } from '../../domainContext.types'
+import { LifeCycleEventType } from '../lifeCycle'
+import { StatusType } from '../logger/isAuthorized'
+
+export function startNetworkErrorCollection(
+  configuration: LogsConfiguration,
+  lifeCycle: LifeCycle,
+  bufferedDataObservable: Observable<BufferedData>
+) {
+  if (!configuration.forwardErrorsToLogs) {
+    return { stop: noop }
+  }
+
+  // Register responseBodyAction getter (no subscription needed)
+  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: XhrCompleteContext | FetchResolveContext) {
+    return !isIntakeUrl(request.url) && !request.isAborted && (isRejected(request) || isServerError(request.status))
+  }
+
+  function handleResponse(type: RequestType, request: XhrCompleteContext | FetchResolveContext) {
+    if (!isNetworkError(request)) {
+      return
+    }
+    const stackTrace = 'error' in request && request.error ? computeStackTrace(request.error) : undefined
+    const stack = stackTrace ? toStackTraceString(stackTrace) : request.responseBody || 'Failed to load'
+    const debugIds = stackTrace ? buildDebugIdByUrl(getStackTraceUrls(stackTrace)) : undefined
+
+    const domainContext: LogsEventDomainContext<typeof ErrorSource.NETWORK> = {
+      handlingStack: request.handlingStack,
+    }
+
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        message: `${format(type)} error ${request.method} ${request.url}`,
+        date: request.startClocks.timeStamp,
+        error: {
+          stack: safeTruncate(stack, DEFAULT_REQUEST_ERROR_RESPONSE_LENGTH_LIMIT, '...'),
+          // We don't know if the error was handled or not, so we set it to undefined
+          handling: undefined,
+        },
+        _kubesense: { debug_ids: debugIds },
+        http: {
+          method: request.method as any, // Cast resource method because of case mismatch cf issue RUMF-1152
+          status_code: request.status,
+          url: request.url,
+        },
+        status: StatusType.error,
+        origin: ErrorSource.NETWORK,
+      },
+      domainContext,
+    })
+  }
+
+  return { stop: () => subscription.unsubscribe() }
+}
+
+function isRejected(request: { status: number; responseType?: string }) {
+  return request.status === 0 && request.responseType !== 'opaque'
+}
+
+function format(type: RequestType) {
+  if (RequestType.XHR === type) {
+    return 'XHR'
+  }
+  return 'Fetch'
+}

package/src/domain/plugins.ts

@@ -0,0 +1,72 @@
+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 function callPluginsMethod<MethodName extends MethodNames>(
+  plugins: LogsPlugin[] | undefined,
+  methodName: MethodName,
+  parameter: MethodParameter<MethodName>
+): void
+export function callPluginsMethod<MethodName extends MethodNames>(
+  plugins: LogsPlugin[] | undefined,
+  methodName: MethodName,
+  parameter: any
+) {
+  if (!plugins) {
+    return
+  }
+  for (const plugin of plugins) {
+    const method = plugin[methodName]
+    if (method) {
+      method(parameter)
+    }
+  }
+}

package/src/domain/remoteSdkConfiguration.ts

@@ -0,0 +1,105 @@
+import type { RemoteSdkConfig } from '@kubesense/kubesense-browser-core'
+import {
+  RawReportType,
+  getCachedSdkConfig,
+  objectValues,
+  readBoolean,
+  readSampleRate,
+  readString,
+  readStringList,
+  refreshSdkConfig,
+} from '@kubesense/kubesense-browser-core'
+import { ConsoleApiName } from '@kubesense/kubesense-js-core/util'
+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 function applyCachedLogsSdkConfiguration(
+  initConfiguration: LogsInitConfiguration
+): LogsRemoteSdkConfigurationResult {
+  const remoteConfig = getCachedSdkConfig(initConfiguration.clientToken)
+  if (!remoteConfig) {
+    return { initConfiguration, logsEnabled: true }
+  }
+  return applyLogsSdkConfiguration(initConfiguration, remoteConfig)
+}
+
+export function applyLogsSdkConfiguration(
+  initConfiguration: LogsInitConfiguration,
+  remoteConfig: RemoteSdkConfig
+): LogsRemoteSdkConfigurationResult {
+  const features = remoteConfig.features as { [key: string]: unknown } | undefined
+  if (readBoolean(features, 'logs') === false) {
+    return { initConfiguration, logsEnabled: false }
+  }
+
+  const logs = remoteConfig.logs
+  if (!logs) {
+    return { initConfiguration, logsEnabled: true }
+  }
+
+  const applied: LogsInitConfiguration = { ...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<T extends string>(value: unknown, allowedValues: readonly T[]): T[] | 'all' | undefined {
+  if (value === 'all') {
+    return 'all'
+  }
+  const names = readStringList(value)?.filter((name): name is T => (allowedValues as readonly string[]).includes(name))
+  return names?.length ? names : undefined
+}
+
+function assign<K extends keyof LogsInitConfiguration>(
+  target: LogsInitConfiguration,
+  key: K,
+  value: LogsInitConfiguration[K] | undefined
+) {
+  if (value !== undefined) {
+    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.
+ */
+export function scheduleLogsSdkConfigurationRefresh(initConfiguration: LogsInitConfiguration) {
+  return refreshSdkConfig(initConfiguration)
+}

package/src/domain/report/reportCollection.ts

@@ -0,0 +1,47 @@
+import type { ClocksState } from '@kubesense/kubesense-js-core/time'
+import type { Context } from '@kubesense/kubesense-browser-core'
+import { timeStampNow } from '@kubesense/kubesense-js-core/time'
+import { ErrorSource, getFileFromStackTraceString, initReportObservable } from '@kubesense/kubesense-browser-core'
+import type { LogsConfiguration } from '../configuration'
+import type { LifeCycle } from '../lifeCycle'
+import { LifeCycleEventType } from '../lifeCycle'
+import { StatusType } from '../logger/isAuthorized'
+import { createErrorFieldFromRawError } from '../createErrorFieldFromRawError'
+
+export interface ProvidedError {
+  startClocks: ClocksState
+  error: unknown
+  context?: Context
+  handlingStack: string
+}
+
+export function startReportCollection(configuration: LogsConfiguration, lifeCycle: 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(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        date: timeStampNow(),
+        message,
+        origin: ErrorSource.REPORT,
+        error,
+        _kubesense: { debug_ids: rawError.debugIds },
+        status,
+      },
+    })
+  })
+
+  return {
+    stop: () => {
+      reportSubscription.unsubscribe()
+    },
+  }
+}

package/src/domain/reportError.ts

@@ -0,0 +1,20 @@
+import { ErrorSource, addTelemetryDebug } from '@kubesense/kubesense-browser-core'
+import { timeStampNow } from '@kubesense/kubesense-js-core/time'
+import type { LifeCycle } from './lifeCycle'
+import { LifeCycleEventType } from './lifeCycle'
+import { StatusType } from './logger/isAuthorized'
+
+export function startReportError(lifeCycle: LifeCycle) {
+  return (message: string) => {
+    lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+      rawLogsEvent: {
+        message,
+        date: timeStampNow(),
+        origin: ErrorSource.AGENT,
+        status: StatusType.error,
+      },
+    })
+    // monitor-until: forever, to keep an eye on the errors reported to customers
+    addTelemetryDebug('Error reported to customer', { 'error.message': message })
+  }
+}

package/src/domain/runtimeError/runtimeErrorCollection.ts

@@ -0,0 +1,51 @@
+import type { ClocksState } from '@kubesense/kubesense-js-core/time'
+import { combine } from '@kubesense/kubesense-js-core/util'
+import type { Context, Observable, BufferedData } from '@kubesense/kubesense-browser-core'
+import { noop, ErrorSource, BufferedDataType } from '@kubesense/kubesense-browser-core'
+import type { LogsConfiguration } from '../configuration'
+import type { LifeCycle } from '../lifeCycle'
+import { LifeCycleEventType } from '../lifeCycle'
+import { StatusType } from '../logger/isAuthorized'
+import { createErrorFieldFromRawError } from '../createErrorFieldFromRawError'
+
+export interface ProvidedError {
+  startClocks: ClocksState
+  error: unknown
+  context?: Context
+  handlingStack: string
+}
+
+export function startRuntimeErrorCollection(
+  configuration: LogsConfiguration,
+  lifeCycle: LifeCycle,
+  bufferedDataObservable: Observable<BufferedData>
+) {
+  if (!configuration.forwardErrorsToLogs) {
+    return { stop: noop }
+  }
+
+  const rawErrorSubscription = bufferedDataObservable.subscribe((bufferedData) => {
+    if (bufferedData.type === BufferedDataType.RUNTIME_ERROR) {
+      const error = bufferedData.data
+      lifeCycle.notify(LifeCycleEventType.RAW_LOG_COLLECTED, {
+        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()
+    },
+  }
+}

package/src/domainContext.types.ts

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