@kubesense/kubesense-browser-core 1.7.0 → 2.0.0-beta.0

package/src/domain/error/error.ts

@@ -1,13 +1,22 @@
+import type { ClocksState } from '@kubesense/kubesense-js-core/time'
+import { isIndexableObject } from '@kubesense/kubesense-js-core/util'
 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'
+import { buildDebugIdByUrl } from '../sourceCodeContext'
+import type { ErrorSource, ErrorHandling, RawError, ErrorWithCause, NonErrorPrefix } from './error.types'
+import { isError, NO_ERROR_STACK_PRESENT_MESSAGE } from './isError'
 
-export const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error'
+export { isError, NO_ERROR_STACK_PRESENT_MESSAGE }
+
+/**
+ * Used when `error.type` cannot be derived from the collected error. Sending a default rather than
+ * nothing keeps those errors groupable and searchable alongside the rest.
+ */
+export const DEFAULT_ERROR_TYPE = 'Error'
 
 interface RawErrorParams {
   stackTrace?: StackTrace
@@ -35,18 +44,62 @@ function computeErrorBase({
   nonErrorPrefix?: NonErrorPrefix
 }) {
   const isErrorInstance = isError(originalError)
-  if (!stackTrace && isErrorInstance) {
-    stackTrace = computeStackTrace(originalError)
-  }
-
   return {
     source,
-    type: stackTrace ? stackTrace.name : undefined,
+    type: computeType(stackTrace, originalError),
     message: computeMessage(stackTrace, isErrorInstance, nonErrorPrefix, originalError),
     stack: stackTrace ? toStackTraceString(stackTrace) : useFallbackStack ? NO_ERROR_STACK_PRESENT_MESSAGE : undefined,
   }
 }
 
+/**
+ * `error.type` is normally the error class name (`TypeError`, `RangeError`...), read from the `name`
+ * property of the collected error. It is unavailable in two cases.
+ *
+ * No `Error` instance ever reached the SDK, because the application threw, rejected or logged
+ * something else: `console.error('message')`, `Promise.reject('reason')`, `addError('message')`. The
+ * runtime type of that value is used instead, which also surfaces that a non-`Error` was thrown in
+ * the first place.
+ *
+ * Or a stack trace was collected but tracekit could not extract a name from it, typically the opaque
+ * cross-origin `"Script error."`. A real error was raised here, so only its name is missing.
+ */
+function computeType(stackTrace: StackTrace | undefined, originalError: unknown): string {
+  if (stackTrace) {
+    return stackTrace.name || DEFAULT_ERROR_TYPE
+  }
+  // `[object String]` -> `String`
+  return /\[object (\w+)\]/.exec(Object.prototype.toString.call(originalError))?.[1] ?? DEFAULT_ERROR_TYPE
+}
+
+export function getStackTraceUrls(stackTrace: StackTrace | undefined): string[] {
+  return stackTrace?.stack.map((frame) => frame.url).filter((url): url is string => !!url) ?? []
+}
+
+function getErrorDebugIds(
+  stackTrace: StackTrace | undefined,
+  errorCauses: Array<{ stackTrace: StackTrace | undefined }>
+) {
+  const errorCausesUrls = errorCauses.flatMap(({ stackTrace }) => getStackTraceUrls(stackTrace))
+  return buildDebugIdByUrl(getStackTraceUrls(stackTrace).concat(errorCausesUrls))
+}
+
+export function flattenErrorCauses(
+  error: ErrorWithCause
+): Array<{ originalError: unknown; stackTrace: StackTrace | undefined }> {
+  const chain: Array<{ originalError: unknown; stackTrace: StackTrace | undefined }> = []
+  let current: unknown = error.cause
+
+  while (current !== undefined && current !== null && chain.length < 10) {
+    const isCurrentError = isError(current)
+    const stackTrace = isCurrentError ? computeStackTrace(current) : undefined
+    chain.push({ originalError: current, stackTrace })
+    current = isCurrentError ? (current as ErrorWithCause).cause : undefined
+  }
+
+  return chain
+}
+
 export function computeRawError({
   stackTrace,
   originalError,
@@ -58,7 +111,21 @@ export function computeRawError({
   source,
   handling,
 }: RawErrorParams): RawError {
-  const errorBase = computeErrorBase({ originalError, stackTrace, source, useFallbackStack, nonErrorPrefix })
+  const errorStackTrace = stackTrace ?? (isError(originalError) ? computeStackTrace(originalError) : undefined)
+
+  const errorCauses = isError(originalError) ? flattenErrorCauses(originalError) : []
+
+  const errorBase = computeErrorBase({
+    originalError,
+    stackTrace: errorStackTrace,
+    source,
+    useFallbackStack,
+    nonErrorPrefix,
+  })
+
+  const rawErrorCauses = errorCauses.map(({ originalError, stackTrace }) =>
+    computeErrorBase({ originalError, stackTrace, source, useFallbackStack: false })
+  )
 
   return {
     startClocks,
@@ -67,7 +134,8 @@ export function computeRawError({
     componentStack,
     originalError,
     ...errorBase,
-    causes: isError(originalError) ? flattenErrorCauses(originalError as ErrorWithCause, source) : undefined,
+    debugIds: getErrorDebugIds(errorStackTrace, errorCauses),
+    causes: rawErrorCauses.length ? rawErrorCauses : undefined,
     fingerprint: tryToGetFingerprint(originalError),
     context: tryToGetErrorContext(originalError),
   }
@@ -91,37 +159,17 @@ function computeMessage(
 }
 
 export function tryToGetFingerprint(originalError: unknown) {
-  return isError(originalError) && 'kubesense_fingerprint' in originalError ? String(originalError.kubesense_fingerprint) : undefined
+  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
+  if (isIndexableObject(originalError)) {
+    return originalError.kubesense_context as Context | undefined
   }
 }
 
 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

@@ -1,5 +1,6 @@
+import type { ClocksState } from '@kubesense/kubesense-js-core/time'
 import type { Context } from '../../tools/serialisation/context'
-import type { ClocksState } from '../../tools/utils/timeUtils'
+import type { DebugIdEntry } from '../sourceCodeContext'
 
 // TS v4.6 introduced Error.cause[1] typed as `Error`. TS v4.8 changed Error.cause to be
 // `unknown`[2].
@@ -16,8 +17,8 @@ export interface ErrorWithCause extends Omit<Error, 'cause'> {
 
 export interface RawErrorCause {
   message: string
-  source: string
-  type?: string
+  source: ErrorSource
+  type: string
   stack?: string
 }
 
@@ -28,7 +29,7 @@ export interface Csp {
 export interface RawError {
   startClocks: ClocksState
   message: string
-  type?: string
+  type: string
   stack?: string
   source: ErrorSource
   originalError?: unknown
@@ -39,6 +40,7 @@ export interface RawError {
   fingerprint?: string
   csp?: Csp
   context?: Context
+  debugIds?: DebugIdEntry[]
 }
 
 export const ErrorSource = {

package/src/domain/error/isError.ts

@@ -0,0 +1,13 @@
+// Leaf module for error primitives with no further dependencies, so cross-cutting
+// modules (e.g. telemetry) can use them without pulling in the whole error module
+// and creating import cycles.
+
+export const NO_ERROR_STACK_PRESENT_MESSAGE = 'No stack, consider using an instance of Error'
+
+export function isError(error: unknown): error is Error {
+  try {
+    return error instanceof Error || Object.prototype.toString.call(error) === '[object Error]'
+  } catch {
+    return false
+  }
+}

package/src/domain/error/trackRuntimeError.ts

@@ -1,9 +1,11 @@
+import { clocksNow } from '@kubesense/kubesense-js-core/time'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
 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 { DOM_EVENT, isEventSupported } from '../../browser/addEventListener'
+import { noop } from '../../tools/utils/functionUtils'
 import { computeRawError, isError } from './error'
 import type { RawError } from './error.types'
 import { ErrorHandling, ErrorSource, NonErrorPrefix } from './error.types'
@@ -34,7 +36,7 @@ export function trackRuntimeError() {
 }
 
 export function instrumentOnError(callback: UnhandledErrorCallback) {
-  return instrumentMethod(getGlobalObject(), 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
+  return instrumentMethod(globalObject, 'onerror', ({ parameters: [messageObj, url, line, column, errorObj] }) => {
     let stackTrace
     if (!isError(errorObj)) {
       stackTrace = computeStackTraceFromOnErrorMessage(messageObj, url, line, column)
@@ -44,7 +46,12 @@ export function instrumentOnError(callback: UnhandledErrorCallback) {
 }
 
 export function instrumentUnhandledRejection(callback: UnhandledErrorCallback) {
-  return instrumentMethod(getGlobalObject(), 'onunhandledrejection', ({ parameters: [e] }) => {
+  // Salesforce LWS does not support the unhandledrejection event. https://developer.salesforce.com/tools/lws-distortion-viewer
+  if (!isEventSupported(globalObject.window, DOM_EVENT.UNHANDLED_REJECTION)) {
+    return { stop: noop }
+  }
+
+  return instrumentMethod(globalObject, 'onunhandledrejection', ({ parameters: [e] }) => {
     callback(e.reason || 'Empty reason')
   })
 }

package/src/domain/eventRateLimiter/createEventRateLimiter.ts

@@ -1,7 +1,5 @@
+import { ONE_MINUTE } from '@kubesense/kubesense-js-core/time'
 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>
 
@@ -10,7 +8,7 @@ const EVENT_RATE_LIMIT = 3000
 
 export function createEventRateLimiter(
   eventType: string,
-  onLimitReached: (limitError: RawError) => void,
+  onLimitReached: (message: string) => void,
   limit = EVENT_RATE_LIMIT
 ) {
   let eventCount = 0
@@ -33,11 +31,7 @@ export function createEventRateLimiter(
       if (eventCount === limit + 1) {
         allowNextEvent = true
         try {
-          onLimitReached({
-            message: `Reached max number of ${eventType}s by minute: ${limit}`,
-            source: ErrorSource.AGENT,
-            startClocks: clocksNow(),
-          })
+          onLimitReached(`Reached max number of ${eventType}s by minute: ${limit}`)
         } finally {
           allowNextEvent = false
         }

package/src/{tools/utils → domain/geo}/geocoding.ts

@@ -1,3 +1,4 @@
+import { fetch } from '../../browser/fetch'
 import type { GeoPosition } from './geolocation'
 
 export interface GeoLocation {
@@ -65,7 +66,7 @@ export function reverseGeocode(
   fetch(url, {
     headers: {
       'User-Agent': userAgent,
-      'Accept': 'application/json',
+      Accept: 'application/json',
     },
   })
     .then((response) => {
@@ -95,13 +96,7 @@ export function reverseGeocodeWithPosition(
     userAgent?: string
   }
 ): void {
-  reverseGeocode(
-    position.latitude,
-    position.longitude,
-    onSuccess,
-    onError,
-    options
-  )
+  reverseGeocode(position.latitude, position.longitude, onSuccess, onError, options)
 }
 
 function parseGeocodingResponse(data: GeocodingResponse): GeoLocationResult {
@@ -140,7 +135,7 @@ export function getLocationName(result: GeoLocationResult): string {
   return parts.join(', ')
 }
 
-export async function reverseGeocodeAsync(
+export function reverseGeocodeAsync(
   latitude: number,
   longitude: number,
   options?: {
@@ -149,17 +144,11 @@ export async function reverseGeocodeAsync(
   }
 ): Promise<GeoLocationResult> {
   return new Promise((resolve, reject) => {
-    reverseGeocode(
-      latitude,
-      longitude,
-      resolve,
-      (error) => reject(new Error(error.message)),
-      options
-    )
+    reverseGeocode(latitude, longitude, resolve, (error) => reject(new Error(error.message)), options)
   })
 }
 
-export async function reverseGeocodeWithPositionAsync(
+export function reverseGeocodeWithPositionAsync(
   position: GeoPosition,
   options?: {
     baseUrl?: string
@@ -167,4 +156,4 @@ export async function reverseGeocodeWithPositionAsync(
   }
 ): Promise<GeoLocationResult> {
   return reverseGeocodeAsync(position.latitude, position.longitude, options)
-}
+}

package/src/{tools/utils → domain/geo}/geolocation.ts

@@ -108,4 +108,4 @@ export function clearWatch(watchId: number): void {
   if (canUseGeoLocation() && watchId >= 0) {
     navigator.geolocation.clearWatch(watchId)
   }
-}
+}

package/src/domain/report/reportObservable.ts

@@ -1,12 +1,12 @@
+import { clocksNow } from '@kubesense/kubesense-js-core/time'
+import { monitor } from '@kubesense/kubesense-js-core/monitor'
 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 { addEventListener, DOM_EVENT, isEventSupported } 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 { buildDebugIdByUrl } from '../sourceCodeContext'
 import type { ReportType, InterventionReport, DeprecationReport } from './browser.types'
 
 export const RawReportType = {
@@ -21,11 +21,11 @@ export type RawReportError = RawError & {
   originalError: SecurityPolicyViolationEvent | DeprecationReport | InterventionReport
 }
 
-export function initReportObservable(configuration: Configuration, apis: RawReportType[]) {
+export function initReportObservable(apis: RawReportType[]) {
   const observables: Array<Observable<RawReportError>> = []
 
   if (apis.includes(RawReportType.cspViolation)) {
-    observables.push(createCspViolationReportObservable(configuration))
+    observables.push(createCspViolationReportObservable())
   }
 
   const reportTypes = apis.filter((api: RawReportType): api is ReportType => api !== RawReportType.cspViolation)
@@ -58,9 +58,14 @@ function createReportObservable(reportTypes: ReportType[]) {
   })
 }
 
-function createCspViolationReportObservable(configuration: Configuration) {
+function createCspViolationReportObservable() {
   return new Observable<RawReportError>((observable) => {
-    const { stop } = addEventListener(configuration, document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
+    // Salesforce does not allow to add a securitypolicyviolation event listener. https://developer.salesforce.com/tools/lws-distortion-viewer
+    if (!isEventSupported(document, DOM_EVENT.SECURITY_POLICY_VIOLATION)) {
+      return
+    }
+
+    const { stop } = addEventListener(document, DOM_EVENT.SECURITY_POLICY_VIOLATION, (event) => {
       observable.notify(buildRawReportErrorFromCspViolation(event))
     })
 
@@ -76,6 +81,7 @@ function buildRawReportErrorFromReport(report: DeprecationReport | InterventionR
     message: `${type}: ${body.message}`,
     originalError: report,
     stack: buildStack(body.id, body.message, body.sourceFile, body.lineNumber, body.columnNumber),
+    debugIds: body.sourceFile ? buildDebugIdByUrl([body.sourceFile]) : undefined,
   })
 }
 
@@ -97,6 +103,7 @@ function buildRawReportErrorFromCspViolation(event: SecurityPolicyViolationEvent
       event.lineNumber,
       event.columnNumber
     ),
+    debugIds: event.sourceFile ? buildDebugIdByUrl([event.sourceFile]) : undefined,
   })
 }
 

package/src/domain/resourceUtils.ts

@@ -8,6 +8,7 @@ export const ResourceType = {
   IMAGE: 'image',
   FONT: 'font',
   MEDIA: 'media',
+  WEBSOCKET: 'websocket',
   OTHER: 'other',
 } as const
 

package/src/domain/sampler.ts

@@ -0,0 +1,59 @@
+export function correctedChildSampleRate(parentRate: number, childRate: number): number {
+  return (parentRate * childRate) / 100
+}
+
+const sampleDecisionCache: Map<number, { sessionId: string; decision: boolean }> = new Map()
+
+export function isSampled(sessionId: string, sampleRate: number): boolean {
+  // Shortcuts for common cases. This is not strictly necessary, but it makes the code faster for
+  // customers willing to ingest all traces.
+  if (sampleRate === 100) {
+    return true
+  }
+
+  if (sampleRate === 0) {
+    return false
+  }
+
+  const cachedDecision = sampleDecisionCache.get(sampleRate)
+  if (sessionId === cachedDecision?.sessionId) {
+    return cachedDecision.decision
+  }
+
+  const decision = sampleUsingKnuthFactor(BigInt(`0x${sessionId.split('-')[4]}`), sampleRate)
+  sampleDecisionCache.set(sampleRate, { sessionId, decision })
+  return decision
+}
+
+// Exported for tests
+export function resetSampleDecisionCache() {
+  sampleDecisionCache.clear()
+}
+
+/**
+ * Perform sampling using the Knuth factor method. This method offer consistent sampling result
+ * based on the provided identifier.
+ *
+ * @param identifier - The identifier to use for sampling.
+ * @param sampleRate - The sample rate in percentage between 0 and 100.
+ */
+export function sampleUsingKnuthFactor(identifier: bigint, sampleRate: number): boolean {
+  // The formula is:
+  //
+  //   (identifier * knuthFactor) % 2^64 < sampleRate * 2^64
+  //
+  // Because JavaScript numbers are 64-bit floats, we can't represent 64-bit integers, and the
+  // modulo would be incorrect. Thus, we are using BigInts here.
+  //
+  // Note: All implementations have slight variations. Some of them use '<=' instead of '<', and
+  // use `sampleRate * 2^64 - 1` instead of `sampleRate * 2^64`. The following implementation
+  // should adhere to the spec and is a bit simpler than using a 2^64-1 limit as there are less
+  // BigInt arithmetic to write. In practice this does not matter, as we are using floating point
+  // numbers in the end, and Number(2n**64n-1n) === Number(2n**64n).
+  const knuthFactor = 1111111111111111111n
+  // Avoid `**` as it can be downleveled to `Math.pow`, which does not support BigInts.
+  // eslint-disable-next-line no-bitwise
+  const twoPow64 = 1n << 64n
+  const hash = (identifier * knuthFactor) % twoPow64
+  return Number(hash) <= (sampleRate / 100) * Number(twoPow64)
+}

package/src/domain/session/sessionConstants.ts

@@ -1,4 +1,4 @@
-import { ONE_HOUR, ONE_MINUTE, ONE_YEAR } from '../../tools/utils/timeUtils'
+import { ONE_HOUR, ONE_MINUTE, ONE_YEAR } from '@kubesense/kubesense-js-core/time'
 
 export const SESSION_TIME_OUT_DELAY = 4 * ONE_HOUR
 export const SESSION_EXPIRATION_DELAY = 15 * ONE_MINUTE
@@ -10,6 +10,7 @@ export const SESSION_NOT_TRACKED = '0'
  */
 export const SessionPersistence = {
   COOKIE: 'cookie',
+  MEMORY: 'memory',
   LOCAL_STORAGE: 'local-storage',
 } as const