@kubesense/kubesense-browser-rum-core 1.7.0 → 2.0.0-beta.1

package/src/domain/action/trackManualActions.ts

@@ -0,0 +1,104 @@
+import type { ClocksState, Duration } from '@kubesense/kubesense-js-core/time'
+import type { Context } from '@kubesense/kubesense-browser-core'
+import { clocksNow } from '@kubesense/kubesense-js-core/time'
+import { generateUUID } from '@kubesense/kubesense-browser-core'
+import type { ActionType, FrustrationType } from '../../rawRumEvent.types'
+import { ActionType as ActionTypeEnum, FrustrationType as FrustrationTypeEnum } from '../../rawRumEvent.types'
+import type { EventCounts } from '../trackEventCounts'
+import { startEventTracker } from '../eventTracker'
+import type { LifeCycle } from '../lifeCycle'
+import { LifeCycleEventType } from '../lifeCycle'
+import { isActionChildEvent } from './isActionChildEvent'
+
+export type ActionCounts = EventCounts
+
+export interface ActionOptions {
+  /**
+   * Action Type
+   *
+   * @default 'custom'
+   */
+  type?: ActionType
+
+  /**
+   * Action context
+   */
+  context?: any
+
+  /**
+   * Action key
+   */
+  actionKey?: string
+}
+
+export interface ManualAction {
+  id: string
+  type: ActionType
+  name: string
+  startClocks: ClocksState
+  duration?: Duration
+  context?: Context
+  handlingStack?: string
+  counts?: ActionCounts
+  frustrationTypes: FrustrationType[]
+}
+
+export interface ActionEventData {
+  name: string
+  type?: ActionType
+  context?: Context
+}
+
+export function trackManualActions(lifeCycle: LifeCycle, onManualActionCompleted: (action: ManualAction) => void) {
+  const actionTracker = startEventTracker<ActionEventData>(lifeCycle)
+  function startManualAction(name: string, options: ActionOptions = {}, startClocks = clocksNow()) {
+    const lookupKey = options.actionKey ?? name
+
+    const startedManualAction = actionTracker.start(
+      lookupKey,
+      startClocks,
+      {
+        name,
+        ...options,
+      },
+      { isChildEvent: isActionChildEvent }
+    )
+
+    lifeCycle.notify(LifeCycleEventType.ACTION_STARTED, startedManualAction)
+  }
+
+  function stopManualAction(name: string, options: ActionOptions = {}, stopClocks = clocksNow()) {
+    const lookupKey = options.actionKey ?? name
+
+    const stopped = actionTracker.stop(lookupKey, stopClocks, options)
+
+    if (!stopped) {
+      return
+    }
+
+    const frustrationTypes: FrustrationType[] = []
+    if (stopped.counts && stopped.counts.errorCount > 0) {
+      frustrationTypes.push(FrustrationTypeEnum.ERROR_CLICK)
+    }
+
+    const manualAction: ManualAction = {
+      ...stopped,
+      type: stopped.type || ActionTypeEnum.CUSTOM,
+      frustrationTypes,
+    }
+
+    onManualActionCompleted(manualAction)
+  }
+
+  function addInstantAction(action: Omit<ManualAction, 'id' | 'duration' | 'counts' | 'frustrationTypes'>) {
+    onManualActionCompleted({ id: generateUUID(), frustrationTypes: [], ...action })
+  }
+
+  return {
+    addAction: addInstantAction,
+    startAction: startManualAction,
+    stopAction: stopManualAction,
+    findActionId: actionTracker.findId,
+    stop: actionTracker.stopAll,
+  }
+}

package/src/domain/assembly.ts

@@ -1,13 +1,7 @@
-import type { RawError, EventRateLimiter } from '@kubesense/kubesense-browser-core'
-import {
-  combine,
-  isEmptyObject,
-  display,
-  createEventRateLimiter,
-  HookNames,
-  DISCARDED,
-  buildTags,
-} from '@kubesense/kubesense-browser-core'
+import type { EventRateLimiter } from '@kubesense/kubesense-browser-core'
+import { isEmptyObject, display, createEventRateLimiter, buildTags } from '@kubesense/kubesense-browser-core'
+import { DISCARDED } from '@kubesense/kubesense-js-core/assembly'
+import { combine } from '@kubesense/kubesense-js-core/util'
 import type { RumEventDomainContext } from '../domainContext.types'
 import type { AssembledRumEvent } from '../rawRumEvent.types'
 import { RumEventType } from '../rawRumEvent.types'
@@ -16,74 +10,60 @@ import { LifeCycleEventType } from './lifeCycle'
 import type { RumConfiguration } from './configuration'
 import type { ModifiableFieldPaths } from './limitModification'
 import { limitModification } from './limitModification'
-import type { Hooks } from './hooks'
+import type { AssembleHookParams, Hooks } from './hooks'
 
-const VIEW_MODIFIABLE_FIELD_PATHS: ModifiableFieldPaths = {
+const COMMON_MODIFIABLE_FIELD_PATHS: ModifiableFieldPaths = {
   'view.name': 'string',
   'view.url': 'string',
   'view.referrer': 'string',
-}
-
-const USER_CUSTOMIZABLE_FIELD_PATHS: ModifiableFieldPaths = {
   context: 'object',
-}
-
-const ROOT_MODIFIABLE_FIELD_PATHS: ModifiableFieldPaths = {
   service: 'string',
   version: 'string',
 }
 
-let modifiableFieldPathsByEvent: { [key in RumEventType]: ModifiableFieldPaths }
+const MODIFIABLE_FIELD_PATHS_BY_EVENT: Record<AssembledRumEvent['type'], ModifiableFieldPaths> = {
+  [RumEventType.VIEW]: {
+    ...COMMON_MODIFIABLE_FIELD_PATHS,
+    'view.performance.lcp.resource_url': 'string',
+  },
+  [RumEventType.ERROR]: {
+    ...COMMON_MODIFIABLE_FIELD_PATHS,
+    'error.message': 'string',
+    'error.stack': 'string',
+    'error.handling_stack': 'string',
+    'error.resource.url': 'string',
+    'error.fingerprint': 'string',
+    '_kubesense.debug_ids': 'array',
+  },
+  [RumEventType.RESOURCE]: {
+    ...COMMON_MODIFIABLE_FIELD_PATHS,
+    'resource.url': 'string',
+    'resource.graphql.variables': 'string',
+    'resource.request.headers': 'object',
+    'resource.response.headers': 'object',
+    'resource.websocket.close_reason': 'string',
+    'resource.websocket.protocol': 'string',
+  },
+  [RumEventType.ACTION]: {
+    ...COMMON_MODIFIABLE_FIELD_PATHS,
+    'action.target.name': 'string',
+  },
+  [RumEventType.LONG_TASK]: {
+    ...COMMON_MODIFIABLE_FIELD_PATHS,
+    'long_task.scripts[].source_url': 'string',
+    'long_task.scripts[].invoker': 'string',
+    '_kubesense.debug_ids': 'array',
+  },
+  [RumEventType.VITAL]: COMMON_MODIFIABLE_FIELD_PATHS,
+}
 
 export function startRumAssembly(
   configuration: RumConfiguration,
   lifeCycle: LifeCycle,
   hooks: Hooks,
-  reportError: (error: RawError) => void,
+  reportError: (message: string) => void,
   eventRateLimit?: number
 ) {
-  modifiableFieldPathsByEvent = {
-    [RumEventType.VIEW]: {
-      'view.performance.lcp.resource_url': 'string',
-      ...USER_CUSTOMIZABLE_FIELD_PATHS,
-      ...VIEW_MODIFIABLE_FIELD_PATHS,
-      ...ROOT_MODIFIABLE_FIELD_PATHS,
-    },
-    [RumEventType.ERROR]: {
-      'error.message': 'string',
-      'error.stack': 'string',
-      'error.resource.url': 'string',
-      'error.fingerprint': 'string',
-      ...USER_CUSTOMIZABLE_FIELD_PATHS,
-      ...VIEW_MODIFIABLE_FIELD_PATHS,
-      ...ROOT_MODIFIABLE_FIELD_PATHS,
-    },
-    [RumEventType.RESOURCE]: {
-      'resource.url': 'string',
-      'resource.graphql.variables': 'string',
-      ...USER_CUSTOMIZABLE_FIELD_PATHS,
-      ...VIEW_MODIFIABLE_FIELD_PATHS,
-      ...ROOT_MODIFIABLE_FIELD_PATHS,
-    },
-    [RumEventType.ACTION]: {
-      'action.target.name': 'string',
-      ...USER_CUSTOMIZABLE_FIELD_PATHS,
-      ...VIEW_MODIFIABLE_FIELD_PATHS,
-      ...ROOT_MODIFIABLE_FIELD_PATHS,
-    },
-    [RumEventType.LONG_TASK]: {
-      'long_task.scripts[].source_url': 'string',
-      'long_task.scripts[].invoker': 'string',
-      ...USER_CUSTOMIZABLE_FIELD_PATHS,
-      ...VIEW_MODIFIABLE_FIELD_PATHS,
-      ...ROOT_MODIFIABLE_FIELD_PATHS,
-    },
-    [RumEventType.VITAL]: {
-      ...USER_CUSTOMIZABLE_FIELD_PATHS,
-      ...VIEW_MODIFIABLE_FIELD_PATHS,
-      ...ROOT_MODIFIABLE_FIELD_PATHS,
-    },
-  }
   const eventRateLimiters = {
     [RumEventType.ERROR]: createEventRateLimiter(RumEventType.ERROR, reportError, eventRateLimit),
     [RumEventType.ACTION]: createEventRateLimiter(RumEventType.ACTION, reportError, eventRateLimit),
@@ -92,19 +72,26 @@ export function startRumAssembly(
 
   lifeCycle.subscribe(
     LifeCycleEventType.RAW_RUM_EVENT_COLLECTED,
-    ({ startTime, duration, rawRumEvent, domainContext }) => {
-      const defaultRumEventAttributes = hooks.triggerHook(HookNames.Assemble, {
+    ({ startClocks, duration, rawRumEvent, domainContext }) => {
+      const assemblyParams = {
         eventType: rawRumEvent.type,
-        startTime,
+        rawRumEvent,
+        domainContext,
+        startTime: startClocks.relative,
         duration,
-      })!
-
+      } as AssembleHookParams
+      const defaultRumEventAttributes = hooks.assembleEventDefaults.trigger(assemblyParams)!
       if (defaultRumEventAttributes === DISCARDED) {
         return
       }
 
-      const serverRumEvent = combine(defaultRumEventAttributes, rawRumEvent, {
-        ddtags: buildTags(configuration).join(','),
+      const rumEventAttributes = hooks.assembleEvent.trigger(assemblyParams)!
+      if (rumEventAttributes === DISCARDED) {
+        return
+      }
+
+      const serverRumEvent = combine(defaultRumEventAttributes, rawRumEvent, rumEventAttributes, {
+        ktags: buildTags(configuration).join(','),
       }) as AssembledRumEvent
 
       if (shouldSend(serverRumEvent, configuration.beforeSend, domainContext, eventRateLimiters)) {
@@ -124,7 +111,7 @@ function shouldSend(
   eventRateLimiters: { [key in RumEventType]?: EventRateLimiter }
 ) {
   if (beforeSend) {
-    const result = limitModification(event, modifiableFieldPathsByEvent[event.type], (event) =>
+    const result = limitModification(event, MODIFIABLE_FIELD_PATHS_BY_EVENT[event.type], (event) =>
       beforeSend(event, domainContext)
     )
     if (result === false && event.type !== RumEventType.VIEW) {