@kubesense/kubesense-browser-core 1.0.0

package/src/domain/error/error.ts

@@ -0,0 +1,127 @@
+import { sanitize } from '../../tools/serialisation/sanitize'
+import type { ClocksState } from '../../tools/utils/timeUtils'
+import type { Context } from '../../tools/serialisation/context'
+import { jsonStringify } from '../../tools/serialisation/jsonStringify'
+import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
+import type { ErrorSource, ErrorHandling, RawError, RawErrorCause, ErrorWithCause, NonErrorPrefix } from './error.types'
+
+export const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error'
+
+interface RawErrorParams {
+  stackTrace?: StackTrace
+  originalError: unknown
+  handlingStack?: string
+  componentStack?: string
+  startClocks: ClocksState
+  nonErrorPrefix: NonErrorPrefix
+  useFallbackStack?: boolean
+  source: ErrorSource
+  handling: ErrorHandling
+}
+
+function computeErrorBase({
+  originalError,
+  stackTrace,
+  source,
+  useFallbackStack = true,
+  nonErrorPrefix,
+}: {
+  originalError: unknown
+  stackTrace?: StackTrace
+  source: ErrorSource
+  useFallbackStack?: boolean
+  nonErrorPrefix?: NonErrorPrefix
+}) {
+  const isErrorInstance = isError(originalError)
+  if (!stackTrace && isErrorInstance) {
+    stackTrace = computeStackTrace(originalError)
+  }
+
+  return {
+    source,
+    type: stackTrace ? stackTrace.name : undefined,
+    message: computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError),
+    stack: stackTrace ? toStackTraceString(stackTrace) : useFallbackStack ? NO_ERROR_STACK_PRESENT_MESSAGE : undefined,
+  }
+}
+
+export function computeRawError({
+  stackTrace,
+  originalError,
+  handlingStack,
+  componentStack,
+  startClocks,
+  nonErrorPrefix,
+  useFallbackStack = true,
+  source,
+  handling,
+}: RawErrorParams): RawError {
+  const errorBase = computeErrorBase({ originalError, stackTrace, source, useFallbackStack, nonErrorPrefix })
+
+  return {
+    startClocks,
+    handling,
+    handlingStack,
+    componentStack,
+    originalError,
+    ...errorBase,
+    causes: isError(originalError) ? flattenErrorCauses(originalError as ErrorWithCause, source) : undefined,
+    fingerprint: tryToGetFingerprint(originalError),
+    context: tryToGetErrorContext(originalError),
+  }
+}
+
+function computeMessage(
+  stackTrace: StackTrace | undefined,
+  isErrorInstance: boolean,
+  nonErrorPrefix: NonErrorPrefix | undefined,
+  originalError: unknown
+) {
+  // Favor stackTrace message only if tracekit has really been able to extract something meaningful (message + name)
+  // TODO rework tracekit integration to avoid scattering error building logic
+  return stackTrace?.message && stackTrace?.name
+    ? stackTrace.message
+    : !isErrorInstance
+      ? nonErrorPrefix
+        ? `${nonErrorPrefix} ${jsonStringify(sanitize(originalError))!}`
+        : jsonStringify(sanitize(originalError))!
+      : 'Empty message'
+}
+
+export function tryToGetFingerprint(originalError: unknown) {
+  return isError(originalError) && 'kubesense_fingerprint' in originalError ? String(originalError.kubesense_fingerprint) : undefined
+}
+
+export function tryToGetErrorContext(originalError: unknown) {
+  if (originalError !== null && typeof originalError === 'object' && 'kubesense_context' in originalError) {
+    return originalError.kubesense_context as Context
+  }
+}
+
+export function getFileFromStackTraceString(stack: string) {
+  return /@ (.+)/.exec(stack)?.[1]
+}
+
+export function isError(error: unknown): error is Error {
+  return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]'
+}
+
+export function flattenErrorCauses(error: ErrorWithCause, parentSource: ErrorSource): RawErrorCause[] | undefined {
+  const causes: RawErrorCause[] = []
+  let currentCause = error.cause
+
+  while (currentCause !== undefined && currentCause !== null && causes.length < 10) {
+    const causeBase = computeErrorBase({
+      originalError: currentCause,
+      source: parentSource,
+      useFallbackStack: false,
+    })
+    
+    causes.push(causeBase)
+
+    currentCause = isError(currentCause) ? (currentCause as ErrorWithCause).cause : undefined
+  }
+  return causes.length ? causes : undefined
+}

package/src/domain/error/error.types.ts

@@ -0,0 +1,64 @@
+import type { Context } from '../../tools/serialisation/context'
+import type { ClocksState } from '../../tools/utils/timeUtils'
+
+// TS v4.6 introduced Error.cause[1] typed as `Error`. TS v4.8 changed Error.cause to be
+// `unknown`[2].
+//
+// Because we still support TS 3.8, we need to declare our own type. We can remove it once we drop
+// support for TS v4.7 and before. The 'cause' property defined by TS needs to be omitted because
+// we define it with a type `unknown` which is incompatible with TS 4.6 and 4.7.
+//
+// [1]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-6/#target-es2022
+// [2]: https://devblogs.microsoft.com/typescript/announcing-typescript-4-8/#lib-d-ts-updates
+export interface ErrorWithCause extends Omit<Error, 'cause'> {
+  cause?: unknown
+}
+
+export interface RawErrorCause {
+  message: string
+  source: string
+  type?: string
+  stack?: string
+}
+
+export interface Csp {
+  disposition: 'enforce' | 'report'
+}
+
+export interface RawError {
+  startClocks: ClocksState
+  message: string
+  type?: string
+  stack?: string
+  source: ErrorSource
+  originalError?: unknown
+  handling?: ErrorHandling
+  handlingStack?: string
+  componentStack?: string
+  causes?: RawErrorCause[]
+  fingerprint?: string
+  csp?: Csp
+  context?: Context
+}
+
+export const ErrorSource = {
+  AGENT: 'agent',
+  CONSOLE: 'console',
+  CUSTOM: 'custom',
+  LOGGER: 'logger',
+  NETWORK: 'network',
+  SOURCE: 'source',
+  REPORT: 'report',
+} as const
+
+export const enum NonErrorPrefix {
+  UNCAUGHT = 'Uncaught',
+  PROVIDED = 'Provided',
+}
+
+export const enum ErrorHandling {
+  HANDLED = 'handled',
+  UNHANDLED = 'unhandled',
+}
+
+export type ErrorSource = (typeof ErrorSource)[keyof typeof ErrorSource]

package/src/domain/error/trackRuntimeError.ts

@@ -0,0 +1,50 @@
+import { instrumentMethod } from '../../tools/instrumentMethod'
+import { Observable } from '../../tools/observable'
+import { clocksNow } from '../../tools/utils/timeUtils'
+import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
+import { computeStackTraceFromOnErrorMessage } from '../../tools/stackTrace/computeStackTrace'
+import { getGlobalObject } from '../../tools/globalObject'
+import { computeRawError, isError } from './error'
+import type { RawError } from './error.types'
+import { ErrorHandling, ErrorSource, NonErrorPrefix } from './error.types'
+
+export type UnhandledErrorCallback = (originalError: unknown, stackTrace?: StackTrace) => any
+
+export function trackRuntimeError() {
+  return new Observable<RawError>((observer) => {
+    const handleRuntimeError = (originalError: unknown, stackTrace?: StackTrace) => {
+      const rawError = computeRawError({
+        stackTrace,
+        originalError,
+        startClocks: clocksNow(),
+        nonErrorPrefix: NonErrorPrefix.UNCAUGHT,
+        source: ErrorSource.SOURCE,
+        handling: ErrorHandling.UNHANDLED,
+      })
+      observer.notify(rawError)
+    }
+    const { stop: stopInstrumentingOnError } = instrumentOnError(handleRuntimeError)
+    const { stop: stopInstrumentingOnUnhandledRejection } = instrumentUnhandledRejection(handleRuntimeError)
+
+    return () => {
+      stopInstrumentingOnError()
+      stopInstrumentingOnUnhandledRejection()
+    }
+  })
+}
+
+export function instrumentOnError(callback: UnhandledErrorCallback) {
+  return instrumentMethod(getGlobalObject(), 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
+    let stackTrace
+    if (!isError(errorObj)) {
+      stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column)
+    }
+    callback(errorObj ?? messageObj, stackTrace)
+  })
+}
+
+export function instrumentUnhandledRejection(callback: UnhandledErrorCallback) {
+  return instrumentMethod(getGlobalObject(), 'onunhandledrejection', ({ parameters: [e] }) => {
+    callback(e.reason || 'Empty reason')
+  })
+}

package/src/domain/eventRateLimiter/createEventRateLimiter.ts

@@ -0,0 +1,49 @@
+import { setTimeout } from '../../tools/timer'
+import { clocksNow, ONE_MINUTE } from '../../tools/utils/timeUtils'
+import type { RawError } from '../error/error.types'
+import { ErrorSource } from '../error/error.types'
+
+export type EventRateLimiter = ReturnType<typeof createEventRateLimiter>
+
+// Limit the maximum number of actions, errors and logs per minutes
+const EVENT_RATE_LIMIT = 3000
+
+export function createEventRateLimiter(
+  eventType: string,
+  onLimitReached: (limitError: RawError) => void,
+  limit = EVENT_RATE_LIMIT
+) {
+  let eventCount = 0
+  let allowNextEvent = false
+
+  return {
+    isLimitReached() {
+      if (eventCount === 0) {
+        setTimeout(() => {
+          eventCount = 0
+        }, ONE_MINUTE)
+      }
+
+      eventCount += 1
+      if (eventCount <= limit || allowNextEvent) {
+        allowNextEvent = false
+        return false
+      }
+
+      if (eventCount === limit + 1) {
+        allowNextEvent = true
+        try {
+          onLimitReached({
+            message: `Reached max number of ${eventType}s by minute: ${limit}`,
+            source: ErrorSource.AGENT,
+            startClocks: clocksNow(),
+          })
+        } finally {
+          allowNextEvent = false
+        }
+      }
+
+      return true
+    },
+  }
+}

package/src/domain/extension/extensionUtils.ts

@@ -0,0 +1,28 @@
+export const EXTENSION_PREFIXES = ['chrome-extension://', 'moz-extension://']
+
+export function containsExtensionUrl(str: string): boolean {
+  return EXTENSION_PREFIXES.some((prefix) => str.includes(prefix))
+}
+
+/**
+ * Utility function to detect if the SDK is being initialized in an unsupported browser extension environment.
+ *
+ * @param windowLocation - The current window location to check
+ * @param stack - The error stack to check for extension URLs
+ * @returns true if running in an unsupported browser extension environment
+ */
+export function isUnsupportedExtensionEnvironment(windowLocation: string, stack: string = '') {
+  // If the page itself is an extension page.
+  if (containsExtensionUrl(windowLocation)) {
+    return false
+  }
+
+  // Since we generate the error on the init, we check the 2nd frame line.
+  const frameLines = stack.split('\n').filter((line) => {
+    const trimmedLine = line.trim()
+    return trimmedLine.length && /^at\s+|@/.test(trimmedLine)
+  })
+  const target = frameLines[1] || ''
+
+  return containsExtensionUrl(target)
+}

package/src/domain/intakeSites.ts

@@ -0,0 +1,6 @@
+export type Site = string
+
+export const INTAKE_SITE_STAGING: Site = 'rum.tyke.ai'
+export const INTAKE_SITE_PROD: Site =  'us2.kubesense.ai'
+
+export const INTAKE_URL_PARAMETERS = ['ksource', 'kubesense-api-key', 'kubesense-request-id']

package/src/domain/report/browser.types.ts

@@ -0,0 +1,38 @@
+export type ReportType = DeprecationReport['type'] | InterventionReport['type']
+
+interface Report {
+  type: ReportType
+  url: string
+  body: DeprecationReportBody | InterventionReportBody
+  toJSON(): any
+}
+
+interface ReportBody {
+  toJSON(): any
+}
+
+export interface DeprecationReport extends Report {
+  type: 'deprecation'
+  body: DeprecationReportBody
+}
+export interface DeprecationReportBody extends ReportBody {
+  id: string
+  message: string
+  lineNumber: number | null
+  columnNumber: number | null
+  sourceFile: string | null
+  anticipatedRemoval: Date | null
+}
+
+export interface InterventionReport extends Report {
+  type: 'intervention'
+  body: InterventionReportBody
+}
+
+export interface InterventionReportBody extends ReportBody {
+  id: string
+  message: string
+  lineNumber: number | null
+  columnNumber: number | null
+  sourceFile: string | null
+}

package/src/domain/report/reportObservable.ts

@@ -0,0 +1,133 @@
+import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
+import { monitor } from '../../tools/monitor'
+import { mergeObservables, Observable } from '../../tools/observable'
+import { addEventListener, DOM_EVENT } from '../../browser/addEventListener'
+import { safeTruncate } from '../../tools/utils/stringUtils'
+import type { Configuration } from '../configuration'
+import type { RawError } from '../error/error.types'
+import { ErrorHandling, ErrorSource } from '../error/error.types'
+import { clocksNow } from '../../tools/utils/timeUtils'
+import type { ReportType, InterventionReport, DeprecationReport } from './browser.types'
+
+export const RawReportType = {
+  intervention: 'intervention',
+  deprecation: 'deprecation',
+  cspViolation: 'csp_violation',
+} as const
+
+export type RawReportType = (typeof RawReportType)[keyof typeof RawReportType]
+
+export type RawReportError = RawError & {
+  originalError: SecurityPolicyViolationEvent | DeprecationReport | InterventionReport
+}
+
+export function initReportObservable(configuration: Configuration, apis: RawReportType[]) {
+  const observables: Array<Observable<RawReportError>> = []
+
+  if (apis.includes(RawReportType.cspViolation)) {
+    observables.push(createCspViolationReportObservable(configuration))
+  }
+
+  const reportTypes = apis.filter((api: RawReportType): api is ReportType => api !== RawReportType.cspViolation)
+  if (reportTypes.length) {
+    observables.push(createReportObservable(reportTypes))
+  }
+
+  return mergeObservables(...observables)
+}
+
+function createReportObservable(reportTypes: ReportType[]) {
+  return new Observable<RawReportError>((observable) => {
+    if (!window.ReportingObserver) {
+      return
+    }
+
+    const handleReports = monitor((reports: Array<DeprecationReport | InterventionReport>, _: ReportingObserver) =>
+      reports.forEach((report) => observable.notify(buildRawReportErrorFromReport(report)))
+    ) as ReportingObserverCallback
+
+    const observer = new window.ReportingObserver(handleReports, {
+      types: reportTypes,
+      buffered: true,
+    })
+
+    observer.observe()
+    return () => {
+      observer.disconnect()
+    }
+  })
+}
+
+function createCspViolationReportObservable(configuration: Configuration) {
+  return new Observable<RawReportError>((observable) => {
+    const { stop } = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
+      observable.notify(buildRawReportErrorFromCspViolation(event))
+    })
+
+    return stop
+  })
+}
+
+function buildRawReportErrorFromReport(report: DeprecationReport | InterventionReport): RawReportError {
+  const { type, body } = report
+
+  return buildRawReportError({
+    type: body.id,
+    message: `${type}: ${body.message}`,
+    originalError: report,
+    stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),
+  })
+}
+
+function buildRawReportErrorFromCspViolation(event: SecurityPolicyViolationEvent): RawReportError {
+  const message = `'${event.blockedURI}' blocked by '${event.effectiveDirective}' directive`
+  return buildRawReportError({
+    type: event.effectiveDirective,
+    message: `${RawReportType.cspViolation}: ${message}`,
+    originalError: event,
+    csp: {
+      disposition: event.disposition,
+    },
+    stack: buildStack(
+      event.effectiveDirective,
+      event.originalPolicy
+        ? `${message} of the policy "${safeTruncate(event.originalPolicy, 100, '...')}"`
+        : 'no policy',
+      event.sourceFile,
+      event.lineNumber,
+      event.columnNumber
+    ),
+  })
+}
+
+function buildRawReportError(partial: Omit<RawReportError, 'startClocks' | 'source' | 'handling'>): RawReportError {
+  return {
+    startClocks: clocksNow(),
+    source: ErrorSource.REPORT,
+    handling: ErrorHandling.UNHANDLED,
+    ...partial,
+  }
+}
+
+function buildStack(
+  name: string,
+  message: string,
+  sourceFile: string | null,
+  lineNumber: number | null,
+  columnNumber: number | null
+): string | undefined {
+  return sourceFile
+    ? toStackTraceString({
+        name,
+        message,
+        stack: [
+          {
+            func: '?',
+            url: sourceFile,
+            line: lineNumber ?? undefined,
+            column: columnNumber ?? undefined,
+          },
+        ],
+      })
+    : undefined
+}

package/src/domain/resourceUtils.ts

@@ -0,0 +1,21 @@
+export const ResourceType = {
+  DOCUMENT: 'document',
+  XHR: 'xhr',
+  BEACON: 'beacon',
+  FETCH: 'fetch',
+  CSS: 'css',
+  JS: 'js',
+  IMAGE: 'image',
+  FONT: 'font',
+  MEDIA: 'media',
+  OTHER: 'other',
+} as const
+
+export type ResourceType = (typeof ResourceType)[keyof typeof ResourceType]
+
+export const RequestType = {
+  FETCH: ResourceType.FETCH,
+  XHR: ResourceType.XHR,
+} as const
+
+export type RequestType = (typeof RequestType)[keyof typeof RequestType]