Add feature operation step vital apis

Author: cy-moi

packages/core/src/tools/experimentalFeatures.ts

@@ -19,6 +19,7 @@ export enum ExperimentalFeature {
   EARLY_REQUEST_COLLECTION = 'early_request_collection',
   WATCH_COOKIE_WITHOUT_LOCK = 'watch_cookie_without_lock',
   USE_TREE_WALKER_FOR_ACTION_NAME = 'use_tree_walker_for_action_name',
+  FEATURE_OPERATION_VITAL = 'feature_operation_vital',
 }
 
 const enabledExperimentalFeatures: Set<ExperimentalFeature> = new Set()

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

@@ -742,6 +742,17 @@ describe('preStartRum', () => {
       strategy.init(DEFAULT_INIT_CONFIGURATION, PUBLIC_API)
       expect(addDurationVitalSpy).toHaveBeenCalledOnceWith(vitalAdd)
     })
+
+    it('addOperationStepVital', () => {
+      const addOperationStepVitalSpy = jasmine.createSpy()
+      doStartRumSpy.and.returnValue({
+        addOperationStepVital: addOperationStepVitalSpy,
+      } as unknown as StartRumResult)
+
+      strategy.addOperationStepVital('foo', 'start')
+      strategy.init(DEFAULT_INIT_CONFIGURATION, PUBLIC_API)
+      expect(addOperationStepVitalSpy).toHaveBeenCalledOnceWith('foo', 'start', undefined, undefined, undefined)
+    })
   })
 
   describe('tracking consent', () => {

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

@@ -25,7 +25,7 @@ import {
   serializeRumConfiguration,
 } from '../domain/configuration'
 import type { ViewOptions } from '../domain/view/trackViews'
-import type { DurationVital, CustomVitalsState } from '../domain/vital/vitalCollection'
+import type { DurationVital, CustomVitalsState, VitalOptions } from '../domain/vital/vitalCollection'
 import { startDurationVital, stopDurationVital } from '../domain/vital/vitalCollection'
 import { callPluginsMethod } from '../domain/plugins'
 import type { StartRumResult } from './startRum'
@@ -148,6 +148,18 @@ export function createPreStartStrategy(
     bufferApiCalls.add((startRumResult) => startRumResult.addDurationVital(vital))
   }
 
+  const addOperationStepVital = (
+    name: string,
+    stepType: 'start' | 'end',
+    operationKey?: string,
+    failureReason?: string,
+    options?: VitalOptions
+  ) => {
+    bufferApiCalls.add((startRumResult) =>
+      startRumResult.addOperationStepVital(name, stepType, operationKey, failureReason, options)
+    )
+  }
+
   const strategy: Strategy = {
     init(initConfiguration, publicApi) {
       if (!initConfiguration) {
@@ -248,6 +260,7 @@ export function createPreStartStrategy(
     },
 
     addDurationVital,
+    addOperationStepVital,
   }
 
   return strategy

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

@@ -34,6 +34,7 @@ const noopStartRum = (): ReturnType<StartRum> => ({
   accountContext: {} as any,
   hooks: {} as any,
   telemetry: {} as any,
+  addOperationStepVital: () => undefined,
 })
 const DEFAULT_INIT_CONFIGURATION = { applicationId: 'xxx', clientToken: 'xxx' }
 const FAKE_WORKER = {} as DeflateWorker
@@ -784,6 +785,66 @@ describe('rum public api', () => {
     })
   })
 
+  describe('startFeatureOperation', () => {
+    it('should call addOperationStepVital on the startRum result with start status', () => {
+      const addOperationStepVitalSpy = jasmine.createSpy()
+      const rumPublicApi = makeRumPublicApi(
+        () => ({ ...noopStartRum(), addOperationStepVital: addOperationStepVitalSpy }),
+        noopRecorderApi,
+        noopProfilerApi
+      )
+      rumPublicApi.init(DEFAULT_INIT_CONFIGURATION)
+      rumPublicApi.startFeatureOperation('foo', '00000000-0000-0000-0000-000000000000')
+      expect(addOperationStepVitalSpy).toHaveBeenCalledWith(
+        'foo',
+        'start',
+        '00000000-0000-0000-0000-000000000000',
+        undefined,
+        undefined
+      )
+    })
+  })
+
+  describe('succeedFeatureOperation', () => {
+    it('should call addOperationStepVital on the startRum result with end status', () => {
+      const addOperationStepVitalSpy = jasmine.createSpy()
+      const rumPublicApi = makeRumPublicApi(
+        () => ({ ...noopStartRum(), addOperationStepVital: addOperationStepVitalSpy }),
+        noopRecorderApi,
+        noopProfilerApi
+      )
+      rumPublicApi.init(DEFAULT_INIT_CONFIGURATION)
+      rumPublicApi.succeedFeatureOperation('foo', '00000000-0000-0000-0000-000000000000')
+      expect(addOperationStepVitalSpy).toHaveBeenCalledWith(
+        'foo',
+        'end',
+        '00000000-0000-0000-0000-000000000000',
+        undefined,
+        undefined
+      )
+    })
+  })
+
+  describe('failFeatureOperation', () => {
+    it('should call addOperationStepVital on the startRum result with end status and failure reason', () => {
+      const addOperationStepVitalSpy = jasmine.createSpy()
+      const rumPublicApi = makeRumPublicApi(
+        () => ({ ...noopStartRum(), addOperationStepVital: addOperationStepVitalSpy }),
+        noopRecorderApi,
+        noopProfilerApi
+      )
+      rumPublicApi.init(DEFAULT_INIT_CONFIGURATION)
+      rumPublicApi.failFeatureOperation('foo', '00000000-0000-0000-0000-000000000000', 'page not found')
+      expect(addOperationStepVitalSpy).toHaveBeenCalledWith(
+        'foo',
+        'end',
+        '00000000-0000-0000-0000-000000000000',
+        'page not found',
+        undefined
+      )
+    })
+  })
+
   it('should provide sdk version', () => {
     const rumPublicApi = makeRumPublicApi(noopStartRum, noopRecorderApi, noopProfilerApi)
     expect(rumPublicApi.version).toBe('test')

packages/rum-core/src/boot/rumPublicApi.ts

@@ -42,8 +42,9 @@ import type { RumConfiguration, RumInitConfiguration } from '../domain/configura
 import type { ViewOptions } from '../domain/view/trackViews'
 import type {
   AddDurationVitalOptions,
-  DurationVitalOptions,
   DurationVitalReference,
+  DurationVitalOptions,
+  VitalOptions,
 } from '../domain/vital/vitalCollection'
 import { createCustomVitalsState } from '../domain/vital/vitalCollection'
 import { callPluginsMethod } from '../domain/plugins'
@@ -427,6 +428,17 @@ export interface RumPublicApi extends PublicApi {
    * @param options - Options for the custom vital (context, description)
    */
   stopDurationVital: (nameOrRef: string | DurationVitalReference, options?: DurationVitalOptions) => void
+
+  /**
+   * Add an operation step vital
+   *
+   * @category Vital
+   * @param name - Name of the operation step
+   * @param options - Options for the operation step (context, description)
+   */
+  startFeatureOperation: (name: string, operationKey?: string, options?: VitalOptions) => void
+  succeedFeatureOperation: (name: string, operationKey?: string, options?: VitalOptions) => void
+  failFeatureOperation: (name: string, operationKey?: string, failureReason?: string, options?: VitalOptions) => void
 }
 
 export interface RecorderApi {
@@ -494,6 +506,7 @@ export interface Strategy {
   startDurationVital: StartRumResult['startDurationVital']
   stopDurationVital: StartRumResult['stopDurationVital']
   addDurationVital: StartRumResult['addDurationVital']
+  addOperationStepVital: StartRumResult['addOperationStepVital']
 }
 
 export function makeRumPublicApi(
@@ -771,6 +784,21 @@ export function makeRumPublicApi(
         description: sanitize(options && options.description) as string | undefined,
       })
     }),
+
+    startFeatureOperation: monitor((name, operationKey, options) => {
+      addTelemetryUsage({ feature: 'add-operation-step-vital', action_type: 'start' })
+      strategy.addOperationStepVital(name, 'start', operationKey, undefined, options)
+    }),
+
+    succeedFeatureOperation: monitor((name, operationKey, options) => {
+      addTelemetryUsage({ feature: 'add-operation-step-vital', action_type: 'succeed' })
+      strategy.addOperationStepVital(name, 'end', operationKey, undefined, options)
+    }),
+
+    failFeatureOperation: monitor((name, operationKey, failureReason, options) => {
+      addTelemetryUsage({ feature: 'add-operation-step-vital', action_type: 'fail' })
+      strategy.addOperationStepVital(name, 'end', operationKey, failureReason, options)
+    }),
   })
 
   return rumPublicApi

packages/rum-core/src/boot/startRum.ts

@@ -236,6 +236,7 @@ export function startRum(
     startDurationVital: vitalCollection.startDurationVital,
     stopDurationVital: vitalCollection.stopDurationVital,
     addDurationVital: vitalCollection.addDurationVital,
+    addOperationStepVital: vitalCollection.addOperationStepVital,
     globalContext,
     userContext,
     accountContext,

packages/rum-core/src/domain/vital/vitalCollection.spec.ts

@@ -1,6 +1,6 @@
 import type { Duration } from '@datadog/browser-core'
-import { mockClock, type Clock } from '@datadog/browser-core/test'
-import { clocksNow } from '@datadog/browser-core'
+import { mockClock, mockExperimentalFeatures, type Clock } from '@datadog/browser-core/test'
+import { clocksNow, ExperimentalFeature } from '@datadog/browser-core'
 import { collectAndValidateRawRumEvents, mockPageStateHistory } from '../../../test'
 import type { RawRumEvent, RawRumVitalEvent } from '../../rawRumEvent.types'
 import { VitalType, RumEventType } from '../../rawRumEvent.types'
@@ -229,7 +229,34 @@ describe('vitalCollection', () => {
         expect(rawRumEvents[0].domainContext).toEqual({})
       })
 
-      it('should create a vital from add API', () => {
+      it('should collect raw rum event from operation step vital', () => {
+        mockExperimentalFeatures([ExperimentalFeature.FEATURE_OPERATION_VITAL])
+        vitalCollection.addOperationStepVital('foo', 'start')
+
+        expect(rawRumEvents[0].startTime).toEqual(jasmine.any(Number))
+        expect(rawRumEvents[0].rawRumEvent).toEqual({
+          date: jasmine.any(Number),
+          vital: {
+            id: jasmine.any(String),
+            type: VitalType.OPERATION_STEP,
+            name: 'foo',
+            step_type: 'start',
+            operation_key: undefined,
+            failure_reason: undefined,
+            description: undefined,
+          },
+          context: undefined,
+          type: RumEventType.VITAL,
+          _dd: {
+            vital: {
+              computed_value: true,
+            },
+          },
+        })
+        expect(rawRumEvents[0].domainContext).toEqual({})
+      })
+
+      it('should create a duration vital from add API', () => {
         vitalCollection.addDurationVital({
           name: 'foo',
           type: VitalType.DURATION,
@@ -244,6 +271,23 @@ describe('vitalCollection', () => {
         expect((rawRumEvents[0].rawRumEvent as RawRumVitalEvent).vital.description).toBe('baz')
         expect((rawRumEvents[0].rawRumEvent as RawRumVitalEvent).context).toEqual({ foo: 'bar' })
       })
+
+      it('should create a operation step vital from add API', () => {
+        mockExperimentalFeatures([ExperimentalFeature.FEATURE_OPERATION_VITAL])
+        vitalCollection.addOperationStepVital('foo', 'end', '00000000-0000-0000-0000-000000000000', 'error', {
+          context: { foo: 'bar' },
+          description: 'baz',
+        })
+
+        expect(rawRumEvents.length).toBe(1)
+        expect((rawRumEvents[0].rawRumEvent as RawRumVitalEvent).vital.step_type).toBe('end')
+        expect((rawRumEvents[0].rawRumEvent as RawRumVitalEvent).vital.operation_key).toBe(
+          '00000000-0000-0000-0000-000000000000'
+        )
+        expect((rawRumEvents[0].rawRumEvent as RawRumVitalEvent).vital.failure_reason).toBe('error')
+        expect((rawRumEvents[0].rawRumEvent as RawRumVitalEvent).vital.description).toBe('baz')
+        expect((rawRumEvents[0].rawRumEvent as RawRumVitalEvent).context).toEqual({ foo: 'bar' })
+      })
     })
   })
 })