Merge branch 'najib.boutaib/RUM-3837-force-replay-recording-on-sample…

…d-out-sessions' (59d7883) into staging-14

 pm_trace_id: 31365005
 feature_branch_pipeline_id: 31365005
 source: to-staging

* commit '59d7883785c4b1f6be30c79e82c0856c1c394918':
  [RUM-3837] Format code
  [RUM-3837] Add unit and E2E tests
  [RUM-3837] Force replay recording on sampled out sessions using public API

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

@@ -43,9 +43,11 @@ import { createPreStartStrategy } from './preStartRum'
 import type { StartRum, StartRumResult } from './startRum'
 
 export type RumPublicApi = ReturnType<typeof makeRumPublicApi>
-
+export interface StartStrategyOptions {
+  forceStart: boolean
+}
 export interface RecorderApi {
-  start: () => void
+  start: (options?: StartStrategyOptions) => void
   stop: () => void
   onRumStart: (
     lifeCycle: LifeCycle,
@@ -288,7 +290,7 @@ export function makeRumPublicApi(startRumImpl: StartRum, recorderApi: RecorderAp
     }),
 
     getSessionReplayLink: monitor(() => recorderApi.getSessionReplayLink()),
-    startSessionReplayRecording: monitor(() => recorderApi.start()),
+    startSessionReplayRecording: monitor((options?: StartStrategyOptions) => recorderApi.start(options)),
     stopSessionReplayRecording: monitor(() => recorderApi.stop()),
   })
 

packages/rum-core/src/index.ts

@@ -1,4 +1,4 @@
-export { RumPublicApi, makeRumPublicApi, RecorderApi } from './boot/rumPublicApi'
+export { RumPublicApi, makeRumPublicApi, RecorderApi, StartStrategyOptions } from './boot/rumPublicApi'
 export { StartRum } from './boot/startRum'
 export {
   RumEvent,

packages/rum/src/boot/recorderApi.spec.ts

@@ -135,6 +135,13 @@ describe('makeRecorderApi', () => {
       expect(startRecordingSpy).not.toHaveBeenCalled()
     })
 
+    it('should start recording if session is tracked without session replay when forced', () => {
+      setupBuilder.withSessionManager(createRumSessionManagerMock().setTrackedWithoutSessionReplay()).build()
+      rumInit()
+      recorderApi.start({ forceStart: true })
+      expect(startRecordingSpy).toHaveBeenCalledTimes(1)
+    })
+
     it('uses the previously created worker if available', () => {
       setupBuilder.build()
       rumInit({ worker: mockWorker })

packages/rum/src/boot/recorderApi.ts

@@ -14,6 +14,7 @@ import type {
   RumSessionManager,
   RecorderApi,
   RumConfiguration,
+  StartStrategyOptions,
 } from '@datadog/browser-rum-core'
 import { LifeCycleEventType } from '@datadog/browser-rum-core'
 import { getReplayStats as getReplayStatsImpl } from '../domain/replayStats'
@@ -57,6 +58,8 @@ type RecorderState =
       stopRecording: () => void
     }
 
+type StartStrategyFn = (options?: StartStrategyOptions) => void
+
 export function makeRecorderApi(
   startRecordingImpl: StartRecording,
   createDeflateWorkerImpl?: CreateDeflateWorker
@@ -76,7 +79,7 @@ export function makeRecorderApi(
     status: RecorderStatus.IntentToStart,
   }
 
-  let startStrategy = () => {
+  let startStrategy: StartStrategyFn = () => {
     state = { status: RecorderStatus.IntentToStart }
   }
   let stopStrategy = () => {
@@ -85,7 +88,7 @@ export function makeRecorderApi(
   let getSessionReplayLinkStrategy = noop as () => string | undefined
 
   return {
-    start: () => startStrategy(),
+    start: (options?: StartStrategyOptions) => startStrategy(options),
     stop: () => stopStrategy(),
     getSessionReplayLink: () => getSessionReplayLinkStrategy(),
     onRumStart: (
@@ -139,9 +142,11 @@ export function makeRecorderApi(
         return cachedDeflateEncoder
       }
 
-      startStrategy = () => {
+      startStrategy = (options?: StartStrategyOptions) => {
         const session = sessionManager.findTrackedSession()
-        if (!session || !session.sessionReplayAllowed) {
+        // If session is undefined (untracked), recording should never start
+        // If session is not allowed for replay and not being forced, recording should not start
+        if (!session || (!session.sessionReplayAllowed && !options?.forceStart)) {
           state = { status: RecorderStatus.IntentToStart }
           return
         }

test/e2e/scenario/recorder/recorder.scenario.ts

@@ -807,6 +807,34 @@ describe('recorder', () => {
       })
   })
 
+  describe('recording of sampled out sessions', () => {
+    createTest('should not start recording when session is sampled out')
+      .withRum({ sessionReplaySampleRate: 0 })
+      .withSetup(bundleSetup)
+      .run(async ({ intakeRegistry }) => {
+        await browserExecute(() => {
+          window.DD_RUM!.startSessionReplayRecording()
+        })
+
+        await flushEvents()
+
+        expect(intakeRegistry.replaySegments.length).toBe(0)
+      })
+
+    createTest('should start recording if forced when session is sampled out')
+      .withRum({ sessionReplaySampleRate: 0 })
+      .withSetup(bundleSetup)
+      .run(async ({ intakeRegistry }) => {
+        await browserExecute(() => {
+          window.DD_RUM!.startSessionReplayRecording({ forceStart: true })
+        })
+
+        await flushEvents()
+
+        expect(intakeRegistry.replaySegments.length).toBe(1)
+      })
+  })
+
   createTest('restarting recording should send a new full snapshot')
     .withRum()
     .withSetup(bundleSetup)