⚗ [RUM-11393] Add Start/StopAction API

packages/rum-core/src/boot/preStartRum.spec.ts

@@ -642,6 +642,8 @@ describe('preStartRum', () => {
           errorCount: 0,
           longTaskCount: 0,
           resourceCount: 0,
+          actionCount: 0,
+          frustrationCount: 0,
         },
       }
       strategy.addAction(customAction)

packages/rum-core/src/domain/action/actionCollection.ts

@@ -15,7 +15,6 @@ import { RumEventType } from '../../rawRumEvent.types'
 import type { LifeCycle, RawRumEventCollectedData } from '../lifeCycle'
 import { LifeCycleEventType } from '../lifeCycle'
 import type { RumConfiguration } from '../configuration'
-import type { RumActionEventDomainContext } from '../../domainContext.types'
 import type { DefaultRumEventAttributes, DefaultTelemetryEventAttributes, Hooks } from '../hooks'
 import type { RumMutationRecord } from '../../browser/domMutationObservable'
 import { trackClickActions } from './trackClickActions'
@@ -134,59 +133,49 @@ export function startActionCollection(
 function processAction(action: AutoAction | CustomAction): RawRumEventCollectedData<RawRumActionEvent> {
   const isAuto = isAutoAction(action)
 
-  const actionEvent: RawRumActionEvent = {
-    type: RumEventType.ACTION,
-    date: action.startClocks.timeStamp,
-    action: {
-      id: action.id,
-      loading_time: discardNegativeDuration(toServerDuration(action.duration)),
-      target: { name: action.name },
-      type: action.type,
-      ...(action.counts && {
+  return {
+    rawRumEvent: {
+      type: RumEventType.ACTION,
+      date: action.startClocks.timeStamp,
+      action: {
+        id: action.id,
+        loading_time: discardNegativeDuration(toServerDuration(action.duration)),
+        target: { name: action.name },
+        type: action.type,
         error: { count: action.counts.errorCount },
         long_task: { count: action.counts.longTaskCount },
         resource: { count: action.counts.resourceCount },
-      }),
-      frustration: isAuto ? { type: action.frustrationTypes } : undefined,
+        frustration: isAuto ? { type: action.frustrationTypes } : undefined,
+      },
+      context: isAuto ? undefined : action.context,
+      _dd: isAuto
+        ? {
+            action: {
+              target: action.target,
+              position: action.position,
+              name_source: action.nameSource,
+            },
+          }
+        : undefined,
     },
-    context: isAuto ? undefined : action.context,
-    _dd: isAuto
-      ? {
-          action: {
-            target: action.target,
-            position: action.position,
-            name_source: action.nameSource,
-          },
-        }
-      : undefined,
-  }
-
-  const domainContext: RumActionEventDomainContext = isAuto
-    ? { events: action.events }
-    : { handlingStack: action.handlingStack }
-
-  return {
-    rawRumEvent: actionEvent,
     duration: action.duration,
     startTime: action.startClocks.relative,
-    domainContext,
+    domainContext: isAuto ? { events: action.events } : { handlingStack: action.handlingStack },
   }
 }
 
 function processInstantAction(action: InstantCustomAction): RawRumEventCollectedData<RawRumActionEvent> {
-  const actionEvent: RawRumActionEvent = {
-    type: RumEventType.ACTION,
-    date: action.startClocks.timeStamp,
-    action: {
-      id: generateUUID(),
-      target: { name: action.name },
-      type: action.type,
-    },
-    context: action.context,
-  }
-
   return {
-    rawRumEvent: actionEvent,
+    rawRumEvent: {
+      type: RumEventType.ACTION,
+      date: action.startClocks.timeStamp,
+      action: {
+        id: generateUUID(),
+        target: { name: action.name },
+        type: action.type,
+      },
+      context: action.context,
+    },
     duration: action.duration,
     startTime: action.startClocks.relative,
     domainContext: { handlingStack: action.handlingStack },

packages/rum-core/src/domain/action/trackAction.ts

@@ -38,43 +38,30 @@ export interface ActionTracker {
 
 export function startActionTracker(lifeCycle: LifeCycle): ActionTracker {
   const history = createValueHistory<string>({ expireDelay: ACTION_CONTEXT_TIME_OUT_DELAY })
-  const activeEventCountSubscriptions = new Set<ReturnType<typeof trackEventCounts>>()
+  const activeSubs = new Set<ReturnType<typeof trackEventCounts>>()
 
   const sessionRenewalSubscription = lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {
     history.reset()
-    activeEventCountSubscriptions.forEach((s) => s.stop())
-    activeEventCountSubscriptions.clear()
+    activeSubs.forEach((s) => s.stop())
+    activeSubs.clear()
   })
 
   function createTrackedAction(startClocks: ClocksState, metadata?: TrackedActionMetadata): TrackedAction {
     const id = generateUUID()
     const historyEntry: ValueHistoryEntry<string> = history.add(id, startClocks.relative)
-    let stopped = false
     let duration: Duration | undefined
 
-    const eventCountsSubscription = trackEventCounts({
+    const sub = trackEventCounts({
       lifeCycle,
       isChildEvent: (event) =>
         event.action !== undefined &&
         (Array.isArray(event.action.id) ? event.action.id.includes(id) : event.action.id === id),
     })
-    activeEventCountSubscriptions.add(eventCountsSubscription)
+    activeSubs.add(sub)
 
-    function stopOrDiscard(endTime?: RelativeTime) {
-      if (stopped) {
-        return
-      }
-      stopped = true
-
-      if (endTime !== undefined) {
-        historyEntry.close(endTime)
-        duration = elapsed(startClocks.relative, endTime)
-      } else {
-        historyEntry.remove()
-      }
-
-      eventCountsSubscription.stop()
-      activeEventCountSubscriptions.delete(eventCountsSubscription)
+    function cleanup() {
+      sub.stop()
+      activeSubs.delete(sub)
     }
 
     return {
@@ -85,32 +72,32 @@ export function startActionTracker(lifeCycle: LifeCycle): ActionTracker {
         return duration
       },
       get counts() {
-        return eventCountsSubscription.eventCounts
+        return sub.eventCounts
+      },
+      stop(endTime: RelativeTime) {
+        historyEntry.close(endTime)
+        duration = elapsed(startClocks.relative, endTime)
+        cleanup()
+      },
+      discard() {
+        historyEntry.remove()
+        cleanup()
       },
-      stop: stopOrDiscard,
-      discard: stopOrDiscard,
     }
   }
 
   function findActionId(startTime?: RelativeTime): string | string[] | undefined {
     const ids = history.findAll(startTime)
-    if (ids.length === 0) {
-      return undefined
-    }
-    return ids
+    return ids.length ? ids : undefined
   }
 
   function stop() {
     sessionRenewalSubscription.unsubscribe()
-    activeEventCountSubscriptions.forEach((s) => s.stop())
-    activeEventCountSubscriptions.clear()
+    activeSubs.forEach((s) => s.stop())
+    activeSubs.clear()
     history.reset()
     history.stop()
   }
 
-  return {
-    createTrackedAction,
-    findActionId,
-    stop,
-  }
+  return { createTrackedAction, findActionId, stop }
 }

test/e2e/scenario/rum/actions.scenario.ts

@@ -612,20 +612,6 @@ test.describe('custom actions with startAction/stopAction', () => {
       )
     })
 
-  createTest('support custom action types')
-    .withRum({ enableExperimentalFeatures: ['start_stop_action'] })
-    .run(async ({ intakeRegistry, flushEvents, page }) => {
-      await page.evaluate(() => {
-        window.DD_RUM!.startAction('swipe_left', { type: 'swipe' })
-        window.DD_RUM!.stopAction('swipe_left')
-      })
-      await flushEvents()
-
-      const actionEvents = intakeRegistry.rumActionEvents
-      expect(actionEvents).toHaveLength(1)
-      expect(actionEvents[0].action.type).toBe('swipe')
-    })
-
   createTest('preserve timing when startAction is called before init')
     .withRum({ enableExperimentalFeatures: ['start_stop_action'] })
     .withRumInit((configuration) => {