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

package/src/domain/telemetry/rawTelemetryEvent.types.ts

@@ -3,7 +3,7 @@ import type { TelemetryEvent, TelemetryConfigurationEvent, TelemetryUsageEvent }
 export const TelemetryType = {
   LOG: 'log',
   CONFIGURATION: 'configuration',
-  USAGE: 'usage'
+  USAGE: 'usage',
 } as const
 
 export const enum StatusType {

package/src/domain/telemetry/telemetry.ts

@@ -1,36 +1,31 @@
+import { clocksNow } from '@kubesense/kubesense-js-core/time'
+import { getDebugMode, combine, globalObject, isWorkerEnvironment } from '@kubesense/kubesense-js-core/util'
+import type { Hook } from '@kubesense/kubesense-js-core/assembly'
+import type { RecursivePartial } from '@kubesense/kubesense-js-core/util'
+import { DISCARDED } from '@kubesense/kubesense-js-core/assembly'
+import { performDraw } from '@kubesense/kubesense-js-core/sample'
+import {
+  createEndpointBuilder,
+  createReplicaEndpointBuilder,
+  INTAKE_SITE_STAGING,
+} from '@kubesense/kubesense-js-core/transport'
+import { startMonitorErrorCollection } from '@kubesense/kubesense-js-core/monitor'
 import type { Context } from '../../tools/serialisation/context'
-import { ConsoleApiName } from '../../tools/display'
-import { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from '../error/error'
+import { NO_ERROR_STACK_PRESENT_MESSAGE, isError } from '../error/isError'
 import { toStackTraceString } from '../../tools/stackTrace/handlingStack'
 import { getExperimentalFeatures } from '../../tools/experimentalFeatures'
 import type { Configuration } from '../configuration'
 import { buildTags } from '../tags'
-import { INTAKE_SITE_STAGING, INTAKE_SITE_PROD } from '../intakeSites'
 import { BufferedObservable, Observable } from '../../tools/observable'
-import { clocksNow } from '../../tools/utils/timeUtils'
-import { displayIfDebugEnabled, startMonitorErrorCollection } from '../../tools/monitor'
+import { display } from '../../tools/display'
 import { sendToExtension } from '../../tools/sendToExtension'
-import { performDraw } from '../../tools/utils/numberUtils'
 import { jsonStringify } from '../../tools/serialisation/jsonStringify'
-import { combine } from '../../tools/mergeInto'
-import type { RawError } from '../error/error.types'
 import { NonErrorPrefix } from '../error/error.types'
 import type { StackTrace } from '../../tools/stackTrace/computeStackTrace'
 import { computeStackTrace } from '../../tools/stackTrace/computeStackTrace'
 import { getConnectivity } from '../connectivity'
-import {
-  canUseEventBridge,
-  createFlushController,
-  createHttpRequest,
-  getEventBridge,
-  createBatch,
-} from '../../transport'
-import type { Encoder } from '../../tools/encoder'
-import type { PageMayExitEvent } from '../../browser/pageMayExitObservable'
-import { DeflateEncoderStreamId } from '../deflate'
-import type { AbstractHooks, RecursivePartial } from '../../tools/abstractHooks'
-import { HookNames, DISCARDED } from '../../tools/abstractHooks'
-import { globalObject, isWorkerEnvironment } from '../../tools/globalObject'
+import { canUseEventBridge, getEventBridge, createBatch } from '../../transport'
+import { noop } from '../../tools/utils/functionUtils'
 import type { TelemetryEvent } from './telemetryEvent.types'
 import type {
   RawTelemetryConfiguration,
@@ -69,13 +64,12 @@ export const enum TelemetryMetrics {
   REMOTE_CONFIGURATION_METRIC_NAME = 'remote configuration metrics',
   RECORDER_INIT_METRICS_TELEMETRY_NAME = 'Recorder init metrics',
   SEGMENT_METRICS_TELEMETRY_NAME = 'Segment network request metrics',
-  INITIAL_VIEW_METRICS_TELEMETRY_NAME = 'Initial view metrics',
+  SESSION_MANAGER_INIT_METRICS_TELEMETRY_NAME = 'Session manager init metrics',
 }
 
 const METRIC_SAMPLE_RATE = 1
 
 const TELEMETRY_EXCLUDED_SITES: string[] = [INTAKE_SITE_STAGING]
-
 const MAX_TELEMETRY_EVENTS_PER_PAGE = 15
 
 let telemetryObservable: BufferedObservable<{ rawEvent: RawTelemetryEvent; metricName?: string }> | undefined
@@ -90,17 +84,18 @@ export function getTelemetryObservable() {
 export function startTelemetry(
   telemetryService: TelemetryService,
   configuration: Configuration,
-  hooks: AbstractHooks,
-  reportError: (error: RawError) => void,
-  pageMayExitObservable: Observable<PageMayExitEvent>,
-  createEncoder: (streamId: DeflateEncoderStreamId) => Encoder
+  hook: Hook<any, any>,
+  sdkName?: string
 ): Telemetry {
   const observable = new Observable<TelemetryEvent & Context>()
-
-  const { stop } = startTelemetryTransport(configuration, reportError, pageMayExitObservable, createEncoder, observable)
-
-  const { enabled, metricsEnabled } = startTelemetryCollection(telemetryService, configuration, hooks, observable)
-
+  const { enabled, metricsEnabled } = startTelemetryCollection(
+    telemetryService,
+    configuration,
+    hook,
+    observable,
+    sdkName
+  )
+  const { stop } = startTelemetryTransport(configuration, observable)
   return {
     stop,
     enabled,
@@ -111,15 +106,17 @@ export function startTelemetry(
 export function startTelemetryCollection(
   telemetryService: TelemetryService,
   configuration: Configuration,
-  hooks: AbstractHooks,
+  hook: Hook<any, any>,
   observable: Observable<TelemetryEvent & Context>,
+  sdkName?: string,
   metricSampleRate = METRIC_SAMPLE_RATE,
   maxTelemetryEventsPerPage = MAX_TELEMETRY_EVENTS_PER_PAGE
 ) {
   const alreadySentEventsByKind: Record<string, Set<string>> = {}
 
   const telemetryEnabled =
-    !TELEMETRY_EXCLUDED_SITES.includes(configuration.kubesenseRumEndpoint) && performDraw(configuration.telemetrySampleRate)
+    !TELEMETRY_EXCLUDED_SITES.includes(configuration.kubesenseRumEndpoint) &&
+    performDraw(configuration.telemetrySampleRate)
 
   const telemetryEnabledPerType = {
     [TelemetryType.LOG]: telemetryEnabled,
@@ -151,7 +148,7 @@ export function startTelemetryCollection(
       return
     }
 
-    const defaultTelemetryEventAttributes = hooks.triggerHook(HookNames.AssembleTelemetry, {
+    const defaultTelemetryEventAttributes = hook.trigger({
       startTime: clocksNow().relative,
     })
 
@@ -198,6 +195,7 @@ export function startTelemetryCollection(
         runtime_env: runtimeEnvInfo,
         connectivity: getConnectivity(),
         sdk_setup: __BUILD_ENV__SDK_SETUP__,
+        sdk_name: sdkName,
       }) as TelemetryEvent['telemetry'],
       ktags: buildTags(configuration).join(','),
       experimental_features: Array.from(getExperimentalFeatures()),
@@ -207,11 +205,8 @@ export function startTelemetryCollection(
   }
 }
 
-function startTelemetryTransport(
+export function startTelemetryTransport(
   configuration: Configuration,
-  reportError: (error: RawError) => void,
-  pageMayExitObservable: Observable<PageMayExitEvent>,
-  createEncoder: (streamId: DeflateEncoderStreamId) => Encoder,
   telemetryObservable: Observable<TelemetryEvent & Context>
 ) {
   const cleanupTasks: Array<() => void> = []
@@ -220,20 +215,15 @@ function startTelemetryTransport(
     const telemetrySubscription = telemetryObservable.subscribe((event) => bridge.send('internal_telemetry', event))
     cleanupTasks.push(telemetrySubscription.unsubscribe)
   } else {
-    const endpoints = [configuration.rumEndpointBuilder]
-    if (configuration.replica && isTelemetryReplicationAllowed(configuration)) {
-      endpoints.push(configuration.replica.rumEndpointBuilder)
+    const endpoints = [createEndpointBuilder(configuration, 'rum')]
+    const replicaEndpoint = createReplicaEndpointBuilder(configuration, 'rum')
+    if (replicaEndpoint && isTelemetryReplicationAllowed(configuration)) {
+      endpoints.push(replicaEndpoint)
     }
     const telemetryBatch = createBatch({
-      encoder: createEncoder(DeflateEncoderStreamId.TELEMETRY),
-      request: createHttpRequest(endpoints, reportError),
-      flushController: createFlushController({
-        pageMayExitObservable,
-
-        // We don't use an actual session expire observable here, to make telemetry collection
-        // independent of the session. This allows to start and send telemetry events earlier.
-        sessionExpireObservable: new Observable(),
-      }),
+      endpoints,
+      // Ignore transport errors for telemetry
+      reportError: noop,
     })
     cleanupTasks.push(telemetryBatch.stop)
     const telemetrySubscription = telemetryObservable.subscribe(telemetryBatch.add)
@@ -265,7 +255,9 @@ function isTelemetryReplicationAllowed(configuration: Configuration) {
 }
 
 export function addTelemetryDebug(message: string, context?: Context) {
-  displayIfDebugEnabled(ConsoleApiName.debug, message, context)
+  if (getDebugMode()) {
+    display.debug('[Telemetry]', message, context)
+  }
   getTelemetryObservable().notify({
     rawEvent: {
       type: TelemetryType.LOG,

package/src/domain/telemetry/telemetryEvent.types.ts

@@ -1,4 +1,3 @@
-/* eslint-disable */
 /**
  * DO NOT MODIFY IT BY HAND. Run `yarn json-schemas:sync` instead.
  */
@@ -7,10 +6,7 @@
  * Schema of all properties of a telemetry event
  */
 export type TelemetryEvent =
-  | TelemetryErrorEvent
-  | TelemetryDebugEvent
-  | TelemetryConfigurationEvent
-  | TelemetryUsageEvent
+  TelemetryErrorEvent | TelemetryDebugEvent | TelemetryConfigurationEvent | TelemetryUsageEvent
 /**
  * Schema of all properties of a telemetry error event
  */
@@ -188,7 +184,7 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
       /**
        * Configure the storage strategy for persisting sessions
        */
-      session_persistence?: 'local-storage' | 'cookie'
+      session_persistence?: 'local-storage' | 'cookie' | 'memory'
       /**
        * Whether contexts are stored in local storage
        */
@@ -389,6 +385,10 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * The version of Unity used in a Unity application
        */
       unity_version?: string
+      /**
+       * The version of MAUI used in a .NET MAUI application
+       */
+      maui_version?: string
       /**
        * The threshold used for iOS App Hangs monitoring (in milliseconds)
        */
@@ -448,7 +448,7 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        */
       sdk_version?: string
       /**
-       * The source of the SDK, e.g., 'browser', 'ios', 'android', 'flutter', 'react-native', 'unity', 'kotlin-multiplatform'.
+       * The source of the SDK, e.g., 'browser', 'ios', 'android', 'flutter', 'react-native', 'unity', 'kotlin-multiplatform', 'maui'.
        */
       source?: string
       /**
@@ -463,6 +463,48 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * Whether a proxy is used for remote configuration
        */
       use_remote_configuration_proxy?: boolean
+      /**
+       * Whether dashboard-managed SDK settings served by the KubeSense collector are enabled
+       */
+      enable_remote_sdk_configuration?: boolean
+      /**
+       * Whether Session Replay recording is restricted to specific routes
+       */
+      use_session_replay_routes?: boolean
+      /**
+       * Whether an explicit list of first-party domains is configured for resource classification
+       */
+      use_first_party_domains?: boolean
+      /**
+       * Metadata of the remote configuration currently applied for this session
+       */
+      remote_configuration?: {
+        /**
+         * Identifier of the remote configuration bundle this metadata belongs to
+         */
+        config_id?: string
+        /**
+         * CDN version identifier of the applied configuration
+         */
+        version_id?: string
+        /**
+         * CDN publish timestamp of the applied configuration, in ms from epoch
+         */
+        last_modified?: number
+        /**
+         * Timestamp at which the device fetched and cached this configuration version, in ms from epoch
+         */
+        last_synced?: number
+        /**
+         * Timestamp at which this configuration version was first observed as applied by the device, in ms from epoch. Stamped once and reused on every subsequent session that runs on the same version
+         */
+        first_applied?: number
+        /**
+         * Identifier of the sync that produced this configuration version, used to deduplicate repeat sessions from the same device without a persistent identifier
+         */
+        sync_id?: string
+        [k: string]: unknown
+      }
       /**
        * The percentage of sessions with Profiling enabled
        */
@@ -471,10 +513,30 @@ export type TelemetryConfigurationEvent = CommonTelemetryProperties & {
        * Whether trace baggage is propagated to child spans
        */
       propagate_trace_baggage?: boolean
+      /**
+       * How the SDK tracks resource request/response headers
+       */
+      track_resource_headers?: 'default_headers' | 'custom'
       /**
        * Whether the beta encode cookie options is enabled
        */
       beta_encode_cookie_options?: boolean
+      /**
+       * Whether the beta partial view updates feature is enabled
+       */
+      beta_enable_view_updates?: boolean
+      /**
+       * Whether the beta track WebSockets feature is enabled
+       */
+      beta_track_web_sockets?: boolean
+      /**
+       * Whether tracing feature's client-side-stats generation is enabled
+       */
+      use_client_side_stats?: boolean
+      /**
+       * Whether trace sampling rules are configured
+       */
+      use_trace_sampling_rules?: boolean
       [k: string]: unknown
     }
     [k: string]: unknown
@@ -528,6 +590,8 @@ export type TelemetryCommonFeaturesUsage =
   | ClearAccount
   | AddFeatureFlagEvaluation
   | AddOperationStepVital
+  | GraphQLRequest
+  | AddViewLoadingTime
 /**
  * Schema of browser specific features usage
  */
@@ -536,10 +600,15 @@ export type TelemetryBrowserFeaturesUsage =
   | StartDurationVital
   | StopDurationVital
   | AddDurationVital
+  | StartAction
+  | StopAction
+  | StartResource
+  | StopResource
+  | SourceCodeContext
 /**
  * Schema of mobile specific features usage
  */
-export type TelemetryMobileFeaturesUsage = AddViewLoadingTime
+export type TelemetryMobileFeaturesUsage = TrackWebView | Timeseries | AndroidNetworkInstrumentation
 
 /**
  * Schema of common properties of Telemetry events
@@ -570,7 +639,17 @@ export interface CommonTelemetryProperties {
   /**
    * The source of this event
    */
-  readonly source: 'android' | 'ios' | 'browser' | 'flutter' | 'react-native' | 'unity' | 'kotlin-multiplatform'
+  readonly source:
+    | 'android'
+    | 'ios'
+    | 'browser'
+    | 'flutter'
+    | 'react-native'
+    | 'unity'
+    | 'kotlin-multiplatform'
+    | 'electron'
+    | 'cpp'
+    | 'maui'
   /**
    * The version of the SDK generating the telemetry event
    */
@@ -612,7 +691,7 @@ export interface CommonTelemetryProperties {
     /**
      * UUID of the action
      */
-    id: string
+    readonly id: string | string[]
     [k: string]: unknown
   }
   /**
@@ -640,6 +719,18 @@ export interface CommonTelemetryProperties {
        * Model of the device
        */
       model?: string
+      /**
+       * Number of logical CPU cores available for scheduling on the device at runtime, as reported by the operating system.
+       */
+      readonly logical_cpu_count?: number
+      /**
+       * Total RAM in megabytes
+       */
+      readonly total_ram?: number
+      /**
+       * Whether the device is considered a low RAM device (Android)
+       */
+      readonly is_low_ram?: boolean
       [k: string]: unknown
     }
     /**
@@ -854,6 +945,32 @@ export interface AddOperationStepVital {
   action_type: 'start' | 'succeed' | 'fail'
   [k: string]: unknown
 }
+export interface GraphQLRequest {
+  /**
+   * GraphQL request detected
+   */
+  feature: 'graphql-request'
+  [k: string]: unknown
+}
+export interface AddViewLoadingTime {
+  /**
+   * addViewLoadingTime API
+   */
+  feature: 'addViewLoadingTime'
+  /**
+   * Whether the view is not available
+   */
+  no_view?: boolean
+  /**
+   * Whether the available view is not active
+   */
+  no_active_view?: boolean
+  /**
+   * Whether this call overwrote a previously set loading time
+   */
+  overwritten?: boolean
+  [k: string]: unknown
+}
 export interface StartSessionReplayRecording {
   /**
    * startSessionReplayRecording API
@@ -886,22 +1003,63 @@ export interface AddDurationVital {
   feature: 'add-duration-vital'
   [k: string]: unknown
 }
-export interface AddViewLoadingTime {
+export interface StartAction {
   /**
-   * addViewLoadingTime API
+   * startAction API
    */
-  feature: 'addViewLoadingTime'
+  feature: 'start-action'
+  [k: string]: unknown
+}
+export interface StopAction {
   /**
-   * Whether the view is not available
+   * stopAction API
+   */
+  feature: 'stop-action'
+  [k: string]: unknown
+}
+export interface StartResource {
+  /**
+   * startResource API
    */
-  no_view: boolean
+  feature: 'start-resource'
+  [k: string]: unknown
+}
+export interface StopResource {
   /**
-   * Whether the available view is not active
+   * stopResource API
+   */
+  feature: 'stop-resource'
+  [k: string]: unknown
+}
+export interface SourceCodeContext {
+  /**
+   * KUBESENSE_SOURCE_CODE_CONTEXT global for microfrontends
+   */
+  feature: 'source-code-context'
+  [k: string]: unknown
+}
+export interface TrackWebView {
+  /**
+   * trackWebView API
+   */
+  feature: 'trackWebView'
+  [k: string]: unknown
+}
+export interface Timeseries {
+  /**
+   * Timeseries tracking enabled
+   */
+  feature: 'timeseries'
+  [k: string]: unknown
+}
+export interface AndroidNetworkInstrumentation {
+  /**
+   * Android network instrumentation
    */
-  no_active_view: boolean
+  feature: 'androidNetworkInstrumentation'
   /**
-   * Whether the loading time was overwritten
+   * The network instrumentation API used
    */
-  overwritten: boolean
+  type: 'CRONET' | 'OKHTTP' | 'LEGACY_OKHTTP'
   [k: string]: unknown
 }

package/src/domain/trackingConsent.ts

@@ -11,24 +11,39 @@ export interface TrackingConsentState {
   update: (trackingConsent: TrackingConsent) => void
   isGranted: () => boolean
   observable: Observable<void>
+  onGrantedOnce: (callback: () => void) => void
 }
 
 export function createTrackingConsentState(currentConsent?: TrackingConsent): TrackingConsentState {
   const observable = new Observable<void>()
 
+  function isGranted() {
+    return currentConsent === TrackingConsent.GRANTED
+  }
+
   return {
     tryToInit(trackingConsent: TrackingConsent) {
       if (!currentConsent) {
         currentConsent = trackingConsent
       }
     },
+    onGrantedOnce(fn) {
+      if (isGranted()) {
+        fn()
+      } else {
+        const subscription = observable.subscribe(() => {
+          if (isGranted()) {
+            fn()
+            subscription.unsubscribe()
+          }
+        })
+      }
+    },
     update(trackingConsent: TrackingConsent) {
       currentConsent = trackingConsent
       observable.notify()
     },
-    isGranted() {
-      return currentConsent === TrackingConsent.GRANTED
-    },
+    isGranted,
     observable,
   }
 }

package/src/domain/userAgentData/userAgentData.ts

@@ -1,4 +1,4 @@
-import { globalObject } from '../../tools/globalObject'
+import { globalObject } from '@kubesense/kubesense-js-core/util'
 
 export interface UserAgentBrowser {
   name: string