✨ [RUMF-867] stabilize the manualSessionReplayRecordingStart option

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

@@ -27,28 +27,33 @@ export interface RumUserConfiguration extends UserConfiguration {
 
 export type RumPublicApi = ReturnType<typeof makeRumPublicApi>
 
-export type StartRum = typeof startRum
+export type StartRum<C extends RumUserConfiguration = RumUserConfiguration> = (
+  userConfiguration: C,
+  getCommonContext: () => CommonContext
+) => StartRumResult
 
-export function makeRumPublicApi(startRumImpl: StartRum) {
+type StartRumResult = ReturnType<typeof startRum>
+
+export function makeRumPublicApi<C extends RumUserConfiguration>(startRumImpl: StartRum<C>) {
   let isAlreadyInitialized = false
 
   const globalContextManager = createContextManager()
   let user: User = {}
 
-  let getInternalContextStrategy: ReturnType<StartRum>['getInternalContext'] = () => undefined
+  let getInternalContextStrategy: StartRumResult['getInternalContext'] = () => undefined
 
   const beforeInitAddTiming = new BoundedBuffer<[string, RelativeTime]>()
-  let addTimingStrategy: ReturnType<StartRum>['addTiming'] = (name) => {
+  let addTimingStrategy: StartRumResult['addTiming'] = (name) => {
     beforeInitAddTiming.add([name, relativeNow()])
   }
 
   const beforeInitAddAction = new BoundedBuffer<[CustomAction, CommonContext]>()
-  let addActionStrategy: ReturnType<StartRum>['addAction'] = (action) => {
+  let addActionStrategy: StartRumResult['addAction'] = (action) => {
     beforeInitAddAction.add([action, clonedCommonContext()])
   }
 
   const beforeInitAddError = new BoundedBuffer<[ProvidedError, CommonContext]>()
-  let addErrorStrategy: ReturnType<StartRum>['addError'] = (providedError) => {
+  let addErrorStrategy: StartRumResult['addError'] = (providedError) => {
     beforeInitAddError.add([providedError, clonedCommonContext()])
   }
 
@@ -60,7 +65,7 @@ export function makeRumPublicApi(startRumImpl: StartRum) {
   }
 
   const rumGlobal = makePublicApi({
-    init: monitor((userConfiguration: RumUserConfiguration) => {
+    init: monitor((userConfiguration: C) => {
       if (
         !checkCookiesAuthorized(buildCookieOptions(userConfiguration)) ||
         !checkIsNotLocalFile() ||

packages/rum-recorder/src/boot/recorder.entry.ts

@@ -1,12 +1,12 @@
 import { defineGlobal, getGlobalObject } from '@datadog/browser-core'
-import { RumPublicApi, startRum } from '@datadog/browser-rum-core'
+import { startRum } from '@datadog/browser-rum-core'
 
 import { startRecording } from './recorder'
-import { makeRumRecorderPublicApi } from './rumRecorderPublicApi'
+import { RumRecorderPublicApi, makeRumRecorderPublicApi } from './rumRecorderPublicApi'
 
 export const datadogRum = makeRumRecorderPublicApi(startRum, startRecording)
 
 interface BrowserWindow extends Window {
-  DD_RUM?: RumPublicApi
+  DD_RUM?: RumRecorderPublicApi
 }
 defineGlobal(getGlobalObject<BrowserWindow>(), 'DD_RUM', datadogRum)

packages/rum-recorder/src/boot/rumRecorderPublicApi.ts

@@ -1,9 +1,14 @@
 import { monitor } from '@datadog/browser-core'
-import { LifeCycleEventType, makeRumPublicApi, StartRum } from '@datadog/browser-rum-core'
+import { LifeCycleEventType, makeRumPublicApi, RumUserConfiguration, StartRum } from '@datadog/browser-rum-core'
 
 import { startRecording } from './recorder'
 
 export type StartRecording = typeof startRecording
+export type RumRecorderPublicApi = ReturnType<typeof makeRumRecorderPublicApi>
+
+export interface RumRecorderUserConfiguration extends RumUserConfiguration {
+  manualSessionReplayRecordingStart?: boolean
+}
 
 const enum RecorderStatus {
   Stopped,
@@ -19,7 +24,7 @@ type RecorderState =
     }
 
 export function makeRumRecorderPublicApi(startRumImpl: StartRum, startRecordingImpl: StartRecording) {
-  const rumRecorderGlobal = makeRumPublicApi((userConfiguration, getCommonContext) => {
+  const rumRecorderGlobal = makeRumPublicApi<RumRecorderUserConfiguration>((userConfiguration, getCommonContext) => {
     let state: RecorderState = {
       status: RecorderStatus.Stopped,
     }
@@ -34,10 +39,9 @@ export function makeRumRecorderPublicApi(startRumImpl: StartRum, startRecordingI
     if (configuration.isEnabled('postpone_start_recording')) {
       ;(rumRecorderGlobal as any).startSessionReplayRecording = monitor(startSessionReplayRecording)
       ;(rumRecorderGlobal as any).stopSessionReplayRecording = monitor(stopSessionReplayRecording)
-      if (!(userConfiguration as any).manualSessionReplayRecordingStart) {
-        startSessionReplayRecording()
-      }
-    } else {
+    }
+
+    if (!userConfiguration.manualSessionReplayRecordingStart) {
       startSessionReplayRecording()
     }