@kubesense/kubesense-browser-core 1.0.0

package/src/browser/cookie.ts

@@ -0,0 +1,122 @@
+import { display } from '../tools/display'
+import { ONE_MINUTE, ONE_SECOND } from '../tools/utils/timeUtils'
+import {
+  findAllCommaSeparatedValues,
+  findCommaSeparatedValue,
+  findCommaSeparatedValues,
+  generateUUID,
+} from '../tools/utils/stringUtils'
+import { buildUrl } from '../tools/utils/urlPolyfill'
+
+export interface CookieOptions {
+  secure?: boolean
+  crossSite?: boolean
+  partitioned?: boolean
+  domain?: string
+}
+
+export function setCookie(name: string, value: string, expireDelay: number = 0, options?: CookieOptions) {
+  const date = new Date()
+  date.setTime(date.getTime() + expireDelay)
+  const expires = `expires=${date.toUTCString()}`
+  const sameSite = options && options.crossSite ? 'none' : 'strict'
+  const domain = options && options.domain ? `;domain=${options.domain}` : ''
+  const secure = options && options.secure ? ';secure' : ''
+  const partitioned = options && options.partitioned ? ';partitioned' : ''
+  document.cookie = `${name}=${value};${expires};path=/;samesite=${sameSite}${domain}${secure}${partitioned}`
+}
+
+/**
+ * Returns the value of the cookie with the given name
+ * If there are multiple cookies with the same name, returns the first one
+ */
+export function getCookie(name: string) {
+  return findCommaSeparatedValue(document.cookie, name)
+}
+
+/**
+ * Returns all the values of the cookies with the given name
+ */
+export function getCookies(name: string): string[] {
+  return findAllCommaSeparatedValues(document.cookie).get(name) || []
+}
+
+let initCookieParsed: Map<string, string> | undefined
+
+/**
+ * Returns a cached value of the cookie. Use this during SDK initialization (and whenever possible)
+ * to avoid accessing document.cookie multiple times.
+ */
+export function getInitCookie(name: string) {
+  if (!initCookieParsed) {
+    initCookieParsed = findCommaSeparatedValues(document.cookie)
+  }
+  return initCookieParsed.get(name)
+}
+
+export function resetInitCookies() {
+  initCookieParsed = undefined
+}
+
+export function deleteCookie(name: string, options?: CookieOptions) {
+  setCookie(name, '', 0, options)
+}
+
+export function areCookiesAuthorized(options: CookieOptions): boolean {
+  if (document.cookie === undefined || document.cookie === null) {
+    return false
+  }
+  try {
+    // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during
+    // the test cookie lifetime
+    const testCookieName = `kubesense_cookie_test_${generateUUID()}`
+    const testCookieValue = 'test'
+    setCookie(testCookieName, testCookieValue, ONE_MINUTE, options)
+    const isCookieCorrectlySet = getCookie(testCookieName) === testCookieValue
+    deleteCookie(testCookieName, options)
+    return isCookieCorrectlySet
+  } catch (error) {
+    display.error(error)
+    return false
+  }
+}
+
+/**
+ * No API to retrieve it, number of levels for subdomain and suffix are unknown
+ * strategy: find the minimal domain on which cookies are allowed to be set
+ * https://web.dev/same-site-same-origin/#site
+ */
+let getCurrentSiteCache: string | undefined
+export function getCurrentSite(hostname = location.hostname, referrer = document.referrer): string | undefined {
+  if (getCurrentSiteCache === undefined) {
+    const defaultHostName = getCookieDefaultHostName(hostname, referrer)
+    if (defaultHostName) {
+      // Use a unique cookie name to avoid issues when the SDK is initialized multiple times during
+      // the test cookie lifetime
+      const testCookieName = `dd_site_test_${generateUUID()}`
+      const testCookieValue = 'test'
+
+      const domainLevels = defaultHostName.split('.')
+      let candidateDomain = domainLevels.pop()!
+      while (domainLevels.length && !getCookie(testCookieName)) {
+        candidateDomain = `${domainLevels.pop()!}.${candidateDomain}`
+        setCookie(testCookieName, testCookieValue, ONE_SECOND, { domain: candidateDomain })
+      }
+      deleteCookie(testCookieName, { domain: candidateDomain })
+      getCurrentSiteCache = candidateDomain
+    }
+  }
+  return getCurrentSiteCache
+}
+
+function getCookieDefaultHostName(hostname: string, referrer: string) {
+  try {
+    return hostname || buildUrl(referrer).hostname
+  } catch {
+    // Ignore
+  }
+}
+
+export function resetGetCurrentSite() {
+  getCurrentSiteCache = undefined
+}

package/src/browser/fetchObservable.ts

@@ -0,0 +1,167 @@
+import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
+import { instrumentMethod } from '../tools/instrumentMethod'
+import { monitorError } from '../tools/monitor'
+import { Observable } from '../tools/observable'
+import type { ClocksState } from '../tools/utils/timeUtils'
+import { clocksNow } from '../tools/utils/timeUtils'
+import { normalizeUrl } from '../tools/utils/urlPolyfill'
+import type { GlobalObject } from '../tools/globalObject'
+import { globalObject } from '../tools/globalObject'
+import { readBytesFromStream } from '../tools/readBytesFromStream'
+import { tryToClone } from '../tools/utils/responseUtils'
+
+interface FetchContextBase {
+  method: string
+  startClocks: ClocksState
+  input: unknown
+  init?: RequestInit
+  url: string
+  handlingStack?: string
+}
+
+export interface FetchStartContext extends FetchContextBase {
+  state: 'start'
+}
+
+export interface FetchResolveContext extends FetchContextBase {
+  state: 'resolve'
+  status: number
+  response?: Response
+  responseBody?: string
+  responseType?: string
+  isAborted: boolean
+  error?: Error
+}
+
+export type FetchContext = FetchStartContext | FetchResolveContext
+
+type ResponseBodyActionGetter = (context: FetchResolveContext) => ResponseBodyAction
+
+/**
+ * Action to take with the response body of a fetch request.
+ * Values are ordered by priority: higher values take precedence when multiple actions are requested.
+ */
+export const enum ResponseBodyAction {
+  IGNORE = 0,
+  // TODO(next-major): Remove the "WAIT" action when `trackEarlyRequests` is removed, as the
+  // duration of fetch requests will always come from PerformanceResourceTiming
+  WAIT = 1,
+  COLLECT = 2,
+}
+
+let fetchObservable: Observable<FetchContext> | undefined
+const responseBodyActionGetters: ResponseBodyActionGetter[] = []
+
+export function initFetchObservable({ responseBodyAction }: { responseBodyAction?: ResponseBodyActionGetter } = {}) {
+  if (responseBodyAction) {
+    responseBodyActionGetters.push(responseBodyAction)
+  }
+  if (!fetchObservable) {
+    fetchObservable = createFetchObservable()
+  }
+  return fetchObservable
+}
+
+export function resetFetchObservable() {
+  fetchObservable = undefined
+  responseBodyActionGetters.length = 0
+}
+
+function createFetchObservable() {
+  return new Observable<FetchContext>((observable) => {
+    if (!globalObject.fetch) {
+      return
+    }
+
+    const { stop } = instrumentMethod(globalObject, 'fetch', (call) => beforeSend(call, observable), {
+      computeHandlingStack: true,
+    })
+
+    return stop
+  })
+}
+
+function beforeSend(
+  { parameters, onPostCall, handlingStack }: InstrumentedMethodCall<GlobalObject, 'fetch'>,
+  observable: Observable<FetchContext>
+) {
+  const [input, init] = parameters
+  let methodFromParams = init && init.method
+
+  if (methodFromParams === undefined && input instanceof Request) {
+    methodFromParams = input.method
+  }
+
+  const method = methodFromParams !== undefined ? String(methodFromParams).toUpperCase() : 'GET'
+  const url = input instanceof Request ? input.url : normalizeUrl(String(input))
+  const startClocks = clocksNow()
+
+  const context: FetchStartContext = {
+    state: 'start',
+    init,
+    input,
+    method,
+    startClocks,
+    url,
+    handlingStack,
+  }
+
+  observable.notify(context)
+
+  // Those properties can be changed by observable subscribers
+  parameters[0] = context.input as RequestInfo | URL
+  parameters[1] = context.init
+
+  onPostCall((responsePromise) => {
+    afterSend(observable, responsePromise, context).catch(monitorError)
+  })
+}
+
+async function afterSend(
+  observable: Observable<FetchContext>,
+  responsePromise: Promise<Response>,
+  startContext: FetchStartContext
+) {
+  const context = startContext as unknown as FetchResolveContext
+  context.state = 'resolve'
+
+  let response: Response
+
+  try {
+    response = await responsePromise
+  } catch (error) {
+    context.status = 0
+    context.isAborted =
+      context.init?.signal?.aborted || (error instanceof DOMException && error.code === DOMException.ABORT_ERR)
+    context.error = error as Error
+    observable.notify(context)
+    return
+  }
+
+  context.response = response
+  context.status = response.status
+  context.responseType = response.type
+  context.isAborted = false
+
+  const responseBodyCondition = responseBodyActionGetters.reduce(
+    (action, getter) => Math.max(action, getter(context)),
+    ResponseBodyAction.IGNORE
+  ) as ResponseBodyAction
+
+  if (responseBodyCondition !== ResponseBodyAction.IGNORE) {
+    const clonedResponse = tryToClone(response)
+    if (clonedResponse && clonedResponse.body) {
+      try {
+        const bytes = await readBytesFromStream(clonedResponse.body, {
+          collectStreamBody: responseBodyCondition === ResponseBodyAction.COLLECT,
+        })
+        context.responseBody = bytes && new TextDecoder().decode(bytes)
+      } catch {
+        // Ignore errors when reading the response body (e.g., stream aborted, network errors)
+        // This is not critical and should not be reported as an SDK error
+      }
+    }
+  }
+
+  observable.notify(context)
+}

package/src/browser/pageMayExitObservable.ts

@@ -0,0 +1,56 @@
+import { Observable } from '../tools/observable'
+import { objectValues } from '../tools/utils/polyfills'
+import type { Configuration } from '../domain/configuration'
+import { addEventListeners, addEventListener, DOM_EVENT } from './addEventListener'
+
+export const PageExitReason = {
+  HIDDEN: 'visibility_hidden',
+  UNLOADING: 'before_unload',
+  PAGEHIDE: 'page_hide',
+  FROZEN: 'page_frozen',
+} as const
+
+export type PageExitReason = (typeof PageExitReason)[keyof typeof PageExitReason]
+
+export interface PageMayExitEvent {
+  reason: PageExitReason
+}
+
+export function createPageMayExitObservable(configuration: Configuration): Observable<PageMayExitEvent> {
+  return new Observable<PageMayExitEvent>((observable) => {
+    const { stop: stopListeners } = addEventListeners(
+      configuration,
+      window,
+      [DOM_EVENT.VISIBILITY_CHANGE, DOM_EVENT.FREEZE],
+      (event) => {
+        if (event.type === DOM_EVENT.VISIBILITY_CHANGE && document.visibilityState === 'hidden') {
+          /**
+           * Only event that guarantee to fire on mobile devices when the page transitions to background state
+           * (e.g. when user switches to a different application, goes to homescreen, etc), or is being unloaded.
+           */
+          observable.notify({ reason: PageExitReason.HIDDEN })
+        } else if (event.type === DOM_EVENT.FREEZE) {
+          /**
+           * After transitioning in background a tab can be freezed to preserve resources. (cf: https://developer.chrome.com/blog/page-lifecycle-api)
+           * Allow to collect events happening between hidden and frozen state.
+           */
+          observable.notify({ reason: PageExitReason.FROZEN })
+        }
+      },
+      { capture: true }
+    )
+
+    const stopBeforeUnloadListener = addEventListener(configuration, window, DOM_EVENT.BEFORE_UNLOAD, () => {
+      observable.notify({ reason: PageExitReason.UNLOADING })
+    }).stop
+
+    return () => {
+      stopListeners()
+      stopBeforeUnloadListener()
+    }
+  })
+}
+
+export function isPageExitReason(reason: string): reason is PageExitReason {
+  return objectValues(PageExitReason).includes(reason as PageExitReason)
+}

package/src/browser/runOnReadyState.ts

@@ -0,0 +1,25 @@
+import type { Configuration } from '../domain/configuration'
+import { noop } from '../tools/utils/functionUtils'
+import { DOM_EVENT, addEventListener } from './addEventListener'
+
+export function runOnReadyState(
+  configuration: Configuration,
+  expectedReadyState: 'complete' | 'interactive',
+  callback: () => void
+): { stop: () => void } {
+  if (document.readyState === expectedReadyState || document.readyState === 'complete') {
+    callback()
+    return { stop: noop }
+  }
+  const eventName = expectedReadyState === 'complete' ? DOM_EVENT.LOAD : DOM_EVENT.DOM_CONTENT_LOADED
+  return addEventListener(configuration, window, eventName, callback, { once: true })
+}
+
+export function asyncRunOnReadyState(
+  configuration: Configuration,
+  expectedReadyState: 'complete' | 'interactive'
+): Promise<void> {
+  return new Promise((resolve) => {
+    runOnReadyState(configuration, expectedReadyState, resolve)
+  })
+}

package/src/browser/xhrObservable.ts

@@ -0,0 +1,134 @@
+import type { InstrumentedMethodCall } from '../tools/instrumentMethod'
+import { instrumentMethod } from '../tools/instrumentMethod'
+import { Observable } from '../tools/observable'
+import type { Duration, ClocksState } from '../tools/utils/timeUtils'
+import { elapsed, clocksNow, timeStampNow } from '../tools/utils/timeUtils'
+import { normalizeUrl } from '../tools/utils/urlPolyfill'
+import { shallowClone } from '../tools/utils/objectUtils'
+import type { Configuration } from '../domain/configuration'
+import { addEventListener } from './addEventListener'
+
+export interface XhrOpenContext {
+  state: 'open'
+  method: string
+  url: string
+}
+
+export interface XhrStartContext extends Omit<XhrOpenContext, 'state'> {
+  state: 'start'
+  startClocks: ClocksState
+  isAborted: boolean
+  xhr: XMLHttpRequest
+  handlingStack?: string
+  requestBody?: unknown
+}
+
+export interface XhrCompleteContext extends Omit<XhrStartContext, 'state'> {
+  state: 'complete'
+  duration: Duration
+  status: number
+  responseBody?: string
+}
+
+export type XhrContext = XhrOpenContext | XhrStartContext | XhrCompleteContext
+
+let xhrObservable: Observable<XhrContext> | undefined
+const xhrContexts = new WeakMap<XMLHttpRequest, XhrContext>()
+
+export function initXhrObservable(configuration: Configuration) {
+  if (!xhrObservable) {
+    xhrObservable = createXhrObservable(configuration)
+  }
+  return xhrObservable
+}
+
+function createXhrObservable(configuration: Configuration) {
+  return new Observable<XhrContext>((observable) => {
+    const { stop: stopInstrumentingStart } = instrumentMethod(XMLHttpRequest.prototype, 'open', openXhr)
+
+    const { stop: stopInstrumentingSend } = instrumentMethod(
+      XMLHttpRequest.prototype,
+      'send',
+      (call) => {
+        sendXhr(call, configuration, observable)
+      },
+      { computeHandlingStack: true }
+    )
+
+    const { stop: stopInstrumentingAbort } = instrumentMethod(XMLHttpRequest.prototype, 'abort', abortXhr)
+
+    return () => {
+      stopInstrumentingStart()
+      stopInstrumentingSend()
+      stopInstrumentingAbort()
+    }
+  })
+}
+
+function openXhr({ target: xhr, parameters: [method, url] }: InstrumentedMethodCall<XMLHttpRequest, 'open'>) {
+  xhrContexts.set(xhr, {
+    state: 'open',
+    method: String(method).toUpperCase(),
+    url: normalizeUrl(String(url)),
+  })
+}
+
+function sendXhr(
+  { target: xhr, parameters: [body], handlingStack }: InstrumentedMethodCall<XMLHttpRequest, 'send'>,
+  configuration: Configuration,
+  observable: Observable<XhrContext>
+) {
+  const context = xhrContexts.get(xhr)
+  if (!context) {
+    return
+  }
+
+  const startContext = context as XhrStartContext
+  startContext.state = 'start'
+  startContext.startClocks = clocksNow()
+  startContext.isAborted = false
+  startContext.xhr = xhr
+  startContext.handlingStack = handlingStack
+  startContext.requestBody = body
+
+  let hasBeenReported = false
+
+  const { stop: stopInstrumentingOnReadyStateChange } = instrumentMethod(xhr, 'onreadystatechange', () => {
+    if (xhr.readyState === XMLHttpRequest.DONE) {
+      // Try to report the XHR as soon as possible, because the XHR may be mutated by the
+      // application during a future event. For example, Angular is calling .abort() on
+      // completed requests during an onreadystatechange event, so the status becomes '0'
+      // before the request is collected.
+      onEnd()
+    }
+  })
+
+  const onEnd = () => {
+    unsubscribeLoadEndListener()
+    stopInstrumentingOnReadyStateChange()
+    if (hasBeenReported) {
+      return
+    }
+    hasBeenReported = true
+
+    const completeContext = context as XhrCompleteContext
+    completeContext.state = 'complete'
+    completeContext.duration = elapsed(startContext.startClocks.timeStamp, timeStampNow())
+    completeContext.status = xhr.status
+    if (typeof xhr.response === 'string') {
+      completeContext.responseBody = xhr.response
+    }
+    observable.notify(shallowClone(completeContext))
+  }
+
+  const { stop: unsubscribeLoadEndListener } = addEventListener(configuration, xhr, 'loadend', onEnd)
+
+  observable.notify(startContext)
+}
+
+function abortXhr({ target: xhr }: InstrumentedMethodCall<XMLHttpRequest, 'abort'>) {
+  const context = xhrContexts.get(xhr) as XhrStartContext | undefined
+  if (context) {
+    context.isAborted = true
+  }
+}

package/src/domain/allowedTrackingOrigins.ts

@@ -0,0 +1,29 @@
+import { display } from '../tools/display'
+import { matchList } from '../tools/matchOption'
+import type { InitConfiguration } from './configuration'
+import { isUnsupportedExtensionEnvironment } from './extension/extensionUtils'
+
+export const ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN =
+  'Running the Browser SDK in a Web extension content script is forbidden unless the `allowedTrackingOrigins` option is provided.'
+export const ERROR_NOT_ALLOWED_TRACKING_ORIGIN = 'SDK initialized on a non-allowed domain.'
+
+export function isAllowedTrackingOrigins(
+  configuration: InitConfiguration,
+  errorStack: string,
+  windowOrigin = typeof location !== 'undefined' ? location.origin : ''
+): boolean {
+  const allowedTrackingOrigins = configuration.allowedTrackingOrigins
+  if (!allowedTrackingOrigins) {
+    if (isUnsupportedExtensionEnvironment(windowOrigin, errorStack)) {
+      display.error(ERROR_DOES_NOT_HAVE_ALLOWED_TRACKING_ORIGIN)
+      return false
+    }
+    return true
+  }
+
+  const isAllowed = matchList(allowedTrackingOrigins, windowOrigin)
+  if (!isAllowed) {
+    display.error(ERROR_NOT_ALLOWED_TRACKING_ORIGIN)
+  }
+  return isAllowed
+}

package/src/domain/bufferedData.ts

@@ -0,0 +1,32 @@
+import { BufferedObservable } from '../tools/observable'
+import type { RawError } from './error/error.types'
+import { trackRuntimeError } from './error/trackRuntimeError'
+
+const BUFFER_LIMIT = 500
+
+export const enum BufferedDataType {
+  RUNTIME_ERROR,
+}
+
+export interface BufferedData {
+  type: BufferedDataType.RUNTIME_ERROR
+  error: RawError
+}
+
+export function startBufferingData(trackRuntimeErrorImpl = trackRuntimeError) {
+  const observable = new BufferedObservable<BufferedData>(BUFFER_LIMIT)
+
+  const runtimeErrorSubscription = trackRuntimeErrorImpl().subscribe((error) => {
+    observable.notify({
+      type: BufferedDataType.RUNTIME_ERROR,
+      error,
+    })
+  })
+
+  return {
+    observable,
+    stop: () => {
+      runtimeErrorSubscription.unsubscribe()
+    },
+  }
+}