@kubesense/kubesense-browser-rum 1.0.0

package/esm/types/sessionReplayConstants.d.ts

@@ -0,0 +1,49 @@
+import type * as SessionReplay from './sessionReplay';
+export declare const RecordType: {
+    FullSnapshot: SessionReplay.BrowserFullSnapshotRecord['type'];
+    IncrementalSnapshot: SessionReplay.BrowserIncrementalSnapshotRecord['type'];
+    Meta: SessionReplay.MetaRecord['type'];
+    Focus: SessionReplay.FocusRecord['type'];
+    ViewEnd: SessionReplay.ViewEndRecord['type'];
+    VisualViewport: SessionReplay.VisualViewportRecord['type'];
+    FrustrationRecord: SessionReplay.FrustrationRecord['type'];
+};
+export type RecordType = (typeof RecordType)[keyof typeof RecordType];
+export declare const NodeType: {
+    Document: SessionReplay.DocumentNode['type'];
+    DocumentType: SessionReplay.DocumentTypeNode['type'];
+    Element: SessionReplay.ElementNode['type'];
+    Text: SessionReplay.TextNode['type'];
+    CDATA: SessionReplay.CDataNode['type'];
+    DocumentFragment: SessionReplay.DocumentFragmentNode['type'];
+};
+export type NodeType = (typeof NodeType)[keyof typeof NodeType];
+export declare const IncrementalSource: {
+    Mutation: SessionReplay.BrowserMutationData['source'];
+    MouseMove: Exclude<SessionReplay.MousemoveData['source'], 6>;
+    MouseInteraction: SessionReplay.MouseInteractionData['source'];
+    Scroll: SessionReplay.ScrollData['source'];
+    ViewportResize: SessionReplay.ViewportResizeData['source'];
+    Input: SessionReplay.InputData['source'];
+    TouchMove: Exclude<SessionReplay.MousemoveData['source'], 1>;
+    MediaInteraction: SessionReplay.MediaInteractionData['source'];
+    StyleSheetRule: SessionReplay.StyleSheetRuleData['source'];
+};
+export type IncrementalSource = (typeof IncrementalSource)[keyof typeof IncrementalSource];
+export declare const MouseInteractionType: {
+    readonly MouseUp: 0;
+    readonly MouseDown: 1;
+    readonly Click: 2;
+    readonly ContextMenu: 3;
+    readonly DblClick: 4;
+    readonly Focus: 5;
+    readonly Blur: 6;
+    readonly TouchStart: 7;
+    readonly TouchEnd: 9;
+};
+export type MouseInteractionType = (typeof MouseInteractionType)[keyof typeof MouseInteractionType];
+export declare const MediaInteractionType: {
+    readonly Play: 0;
+    readonly Pause: 1;
+};
+export type MediaInteractionType = (typeof MediaInteractionType)[keyof typeof MediaInteractionType];

package/esm/types/sessionReplayConstants.js

@@ -0,0 +1,46 @@
+export const RecordType = {
+    FullSnapshot: 2,
+    IncrementalSnapshot: 3,
+    Meta: 4,
+    Focus: 6,
+    ViewEnd: 7,
+    VisualViewport: 8,
+    FrustrationRecord: 9,
+};
+export const NodeType = {
+    Document: 0,
+    DocumentType: 1,
+    Element: 2,
+    Text: 3,
+    CDATA: 4,
+    DocumentFragment: 11,
+};
+export const IncrementalSource = {
+    Mutation: 0,
+    MouseMove: 1,
+    MouseInteraction: 2,
+    Scroll: 3,
+    ViewportResize: 4,
+    Input: 5,
+    TouchMove: 6,
+    MediaInteraction: 7,
+    StyleSheetRule: 8,
+    // CanvasMutation : 9,
+    // Font : 10,
+};
+export const MouseInteractionType = {
+    MouseUp: 0,
+    MouseDown: 1,
+    Click: 2,
+    ContextMenu: 3,
+    DblClick: 4,
+    Focus: 5,
+    Blur: 6,
+    TouchStart: 7,
+    TouchEnd: 9,
+};
+export const MediaInteractionType = {
+    Play: 0,
+    Pause: 1,
+};
+//# sourceMappingURL=sessionReplayConstants.js.map

package/esm/types/sessionReplayConstants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sessionReplayConstants.js","sourceRoot":"","sources":["../../src/types/sessionReplayConstants.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAQnB;IACF,YAAY,EAAE,CAAC;IACf,mBAAmB,EAAE,CAAC;IACtB,IAAI,EAAE,CAAC;IACP,KAAK,EAAE,CAAC;IACR,OAAO,EAAE,CAAC;IACV,cAAc,EAAE,CAAC;IACjB,iBAAiB,EAAE,CAAC;CACZ,CAAA;AAIV,MAAM,CAAC,MAAM,QAAQ,GAOjB;IACF,QAAQ,EAAE,CAAC;IACX,YAAY,EAAE,CAAC;IACf,OAAO,EAAE,CAAC;IACV,IAAI,EAAE,CAAC;IACP,KAAK,EAAE,CAAC;IACR,gBAAgB,EAAE,EAAE;CACZ,CAAA;AAIV,MAAM,CAAC,MAAM,iBAAiB,GAU1B;IACF,QAAQ,EAAE,CAAC;IACX,SAAS,EAAE,CAAC;IACZ,gBAAgB,EAAE,CAAC;IACnB,MAAM,EAAE,CAAC;IACT,cAAc,EAAE,CAAC;IACjB,KAAK,EAAE,CAAC;IACR,SAAS,EAAE,CAAC;IACZ,gBAAgB,EAAE,CAAC;IACnB,cAAc,EAAE,CAAC;IACjB,sBAAsB;IACtB,aAAa;CACL,CAAA;AAIV,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,OAAO,EAAE,CAAC;IACV,SAAS,EAAE,CAAC;IACZ,KAAK,EAAE,CAAC;IACR,WAAW,EAAE,CAAC;IACd,QAAQ,EAAE,CAAC;IACX,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC;IACP,UAAU,EAAE,CAAC;IACb,QAAQ,EAAE,CAAC;CACH,CAAA;AAIV,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,IAAI,EAAE,CAAC;IACP,KAAK,EAAE,CAAC;CACA,CAAA"}

package/internal/package.json

@@ -0,0 +1,6 @@
+{
+  "private": true,
+  "main": "../cjs/entries/internal.js",
+  "module": "../esm/entries/internal.js",
+  "types": "../cjs/entries/internal.d.ts"
+}

package/internal-synthetics/package.json

@@ -0,0 +1,6 @@
+{
+  "private": true,
+  "main": "../cjs/entries/internalSynthetics.js",
+  "module": "../esm/entries/internalSynthetics.js",
+  "types": "../cjs/entries/internalSynthetics.d.ts"
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@kubesense/kubesense-browser-rum",
+  "version": "1.0.0",
+  "license": "Apache-2.0",
+  "main": "cjs/entries/main.js",
+  "module": "esm/entries/main.js",
+  "types": "cjs/entries/main.d.ts",
+  "scripts": {
+    "build": "node ../../scripts/build/build-package.ts --modules --bundle kubesense-rum.js",
+    "build:bundle": "node ../../scripts/build/build-package.ts --bundle kubesense-rum.js"
+  },
+  "dependencies": {
+    "@kubesense/kubesense-browser-core": "1.0.0",
+    "@kubesense/kubesense-browser-rum-core": "1.0.0"
+  },
+  "peerDependencies": {
+    "@kubesense/kubesense-browser-logs": "1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@kubesense/kubesense-browser-logs": {
+      "optional": true
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kubesense-ai/kubesense-browser-sdk.git",
+    "directory": "packages/rum"
+  },
+  "devDependencies": {
+    "@types/pako": "2.0.4",
+    "pako": "2.1.0"
+  },
+  "volta": {
+    "extends": "../../package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "5cac939a4795c5a54c2b29417e6434a8a3078d4f"
+}

package/src/boot/isBrowserSupported.ts

@@ -0,0 +1,14 @@
+/**
+ * Test for Browser features used while recording
+ */
+export function isBrowserSupported() {
+  return (
+    // Array.from is a bit less supported by browsers than CSSSupportsRule, but has higher chances
+    // to be polyfilled. Test for both to be more confident. We could add more things if we find out
+    // this test is not sufficient.
+    typeof Array.from === 'function' &&
+    typeof CSSSupportsRule === 'function' &&
+    typeof URL.createObjectURL === 'function' &&
+    'forEach' in NodeList.prototype
+  )
+}

package/src/boot/lazyLoadProfiler.ts

@@ -0,0 +1,21 @@
+import { reportScriptLoadingError } from '../domain/scriptLoadingError'
+import type { createRumProfiler } from '../domain/profiling/profiler'
+
+export async function lazyLoadProfiler(
+  importProfilerImpl = importProfiler
+): Promise<typeof createRumProfiler | undefined> {
+  try {
+    return await importProfilerImpl()
+  } catch (error: unknown) {
+    reportScriptLoadingError({
+      error,
+      source: 'Profiler',
+      scriptType: 'module',
+    })
+  }
+}
+
+async function importProfiler() {
+  const module = await import(/* webpackChunkName: "profiler" */ '../domain/profiling/profiler')
+  return module.createRumProfiler
+}

package/src/boot/lazyLoadRecorder.ts

@@ -0,0 +1,21 @@
+import { reportScriptLoadingError } from '../domain/scriptLoadingError'
+import type { startRecording } from './startRecording'
+
+export async function lazyLoadRecorder(
+  importRecorderImpl = importRecorder
+): Promise<typeof startRecording | undefined> {
+  try {
+    return await importRecorderImpl()
+  } catch (error: unknown) {
+    reportScriptLoadingError({
+      error,
+      source: 'Recorder',
+      scriptType: 'module',
+    })
+  }
+}
+
+async function importRecorder() {
+  const module = await import(/* webpackChunkName: "recorder" */ './startRecording')
+  return module.startRecording
+}

package/src/boot/postStartStrategy.ts

@@ -0,0 +1,176 @@
+import type {
+  LifeCycle,
+  RumConfiguration,
+  RumSessionManager,
+  StartRecordingOptions,
+  ViewHistory,
+  RumSession,
+} from '@kubesense/kubesense-browser-rum-core'
+import { LifeCycleEventType, SessionReplayState } from '@kubesense/kubesense-browser-rum-core'
+import type { Telemetry, DeflateEncoder } from '@kubesense/kubesense-browser-core'
+import { asyncRunOnReadyState, monitorError, Observable } from '@kubesense/kubesense-browser-core'
+import { getSessionReplayLink } from '../domain/getSessionReplayLink'
+import { startRecorderInitTelemetry } from '../domain/startRecorderInitTelemetry'
+import type { startRecording } from './startRecording'
+
+export type StartRecording = typeof startRecording
+
+export const enum RecorderStatus {
+  // The recorder is stopped.
+  Stopped,
+  // The user started the recording while it wasn't possible yet. The recorder should start as soon
+  // as possible.
+  IntentToStart,
+  // The recorder is starting. It does not record anything yet.
+  Starting,
+  // The recorder is started, it records the session.
+  Started,
+}
+
+export type RecorderInitEvent =
+  | { type: 'start'; forced: boolean }
+  | { type: 'document-ready' }
+  | { type: 'recorder-settled' }
+  | { type: 'aborted' }
+  | { type: 'deflate-encoder-load-failed' }
+  | { type: 'recorder-load-failed' }
+  | { type: 'succeeded' }
+
+export interface Strategy {
+  start: (options?: StartRecordingOptions) => void
+  stop: () => void
+  isRecording: () => boolean
+  getSessionReplayLink: () => string | undefined
+}
+
+export function createPostStartStrategy(
+  configuration: RumConfiguration,
+  lifeCycle: LifeCycle,
+  sessionManager: RumSessionManager,
+  viewHistory: ViewHistory,
+  loadRecorder: () => Promise<StartRecording | undefined>,
+  getOrCreateDeflateEncoder: () => DeflateEncoder | undefined,
+  telemetry: Telemetry
+): Strategy {
+  let status = RecorderStatus.Stopped
+  let stopRecording: () => void
+
+  lifeCycle.subscribe(LifeCycleEventType.SESSION_EXPIRED, () => {
+    if (status === RecorderStatus.Starting || status === RecorderStatus.Started) {
+      stop()
+      status = RecorderStatus.IntentToStart
+    }
+  })
+
+  lifeCycle.subscribe(LifeCycleEventType.SESSION_RENEWED, () => {
+    if (status === RecorderStatus.IntentToStart) {
+      start()
+    }
+  })
+
+  const observable = new Observable<RecorderInitEvent>()
+  startRecorderInitTelemetry(telemetry, observable)
+
+  const doStart = async (forced: boolean) => {
+    observable.notify({ type: 'start', forced })
+
+    const [startRecordingImpl] = await Promise.all([
+      notifyWhenSettled(observable, { type: 'recorder-settled' }, loadRecorder()),
+      notifyWhenSettled(observable, { type: 'document-ready' }, asyncRunOnReadyState(configuration, 'interactive')),
+    ])
+
+    if (status !== RecorderStatus.Starting) {
+      observable.notify({ type: 'aborted' })
+      return
+    }
+
+    if (!startRecordingImpl) {
+      status = RecorderStatus.Stopped
+      observable.notify({ type: 'recorder-load-failed' })
+      return
+    }
+
+    const deflateEncoder = getOrCreateDeflateEncoder()
+    if (!deflateEncoder) {
+      status = RecorderStatus.Stopped
+      observable.notify({ type: 'deflate-encoder-load-failed' })
+      return
+    }
+
+    ;({ stop: stopRecording } = startRecordingImpl(
+      lifeCycle,
+      configuration,
+      sessionManager,
+      viewHistory,
+      deflateEncoder,
+      telemetry
+    ))
+
+    status = RecorderStatus.Started
+    observable.notify({ type: 'succeeded' })
+  }
+
+  function start(options?: StartRecordingOptions) {
+    const session = sessionManager.findTrackedSession()
+    if (canStartRecording(session, options)) {
+      status = RecorderStatus.IntentToStart
+      return
+    }
+
+    if (isRecordingInProgress(status)) {
+      return
+    }
+
+    status = RecorderStatus.Starting
+
+    const forced = shouldForceReplay(session!, options) || false
+
+    // Intentionally not awaiting doStart() to keep it asynchronous
+    doStart(forced).catch(monitorError)
+
+    if (forced) {
+      sessionManager.setForcedReplay()
+    }
+  }
+
+  function stop() {
+    if (status === RecorderStatus.Started) {
+      stopRecording?.()
+    }
+
+    status = RecorderStatus.Stopped
+  }
+
+  return {
+    start,
+    stop,
+    getSessionReplayLink() {
+      return getSessionReplayLink(configuration, sessionManager, viewHistory, status !== RecorderStatus.Stopped)
+    },
+    isRecording: () => status === RecorderStatus.Started,
+  }
+}
+
+function canStartRecording(session: RumSession | undefined, options?: StartRecordingOptions) {
+  return !session || (session.sessionReplay === SessionReplayState.OFF && (!options || !options.force))
+}
+
+function isRecordingInProgress(status: RecorderStatus) {
+  return status === RecorderStatus.Starting || status === RecorderStatus.Started
+}
+
+function shouldForceReplay(session: RumSession, options?: StartRecordingOptions) {
+  return options && options.force && session.sessionReplay === SessionReplayState.OFF
+}
+
+async function notifyWhenSettled<Event, Result>(
+  observable: Observable<Event>,
+  event: Event,
+  promise: Promise<Result>
+): Promise<Result> {
+  try {
+    return await promise
+  } finally {
+    observable.notify(event)
+  }
+}

package/src/boot/preStartStrategy.ts

@@ -0,0 +1,34 @@
+import { noop } from '@kubesense/kubesense-browser-core'
+import type { RumConfiguration } from '@kubesense/kubesense-browser-rum-core'
+import type { Strategy } from './postStartStrategy'
+
+const enum PreStartRecorderStatus {
+  None,
+  HadManualStart,
+  HadManualStop,
+}
+
+export function createPreStartStrategy(): {
+  strategy: Strategy
+  shouldStartImmediately: (configuration: RumConfiguration) => boolean
+} {
+  let status = PreStartRecorderStatus.None
+  return {
+    strategy: {
+      start() {
+        status = PreStartRecorderStatus.HadManualStart
+      },
+      stop() {
+        status = PreStartRecorderStatus.HadManualStop
+      },
+      isRecording: () => false,
+      getSessionReplayLink: noop as () => string | undefined,
+    },
+    shouldStartImmediately(configuration) {
+      return (
+        status === PreStartRecorderStatus.HadManualStart ||
+        (status === PreStartRecorderStatus.None && !configuration.startSessionReplayRecordingManually)
+      )
+    },
+  }
+}

package/src/boot/profilerApi.ts

@@ -0,0 +1,86 @@
+import type {
+  LifeCycle,
+  ViewHistory,
+  RumSessionManager,
+  RumConfiguration,
+  ProfilerApi,
+  Hooks,
+  LongTaskContexts,
+} from '@kubesense/kubesense-browser-rum-core'
+import type { DeflateEncoderStreamId, Encoder } from '@kubesense/kubesense-browser-core'
+import { isSampled } from '@kubesense/kubesense-browser-rum-core'
+import { addTelemetryDebug, monitorError } from '@kubesense/kubesense-browser-core'
+import type { RUMProfiler } from '../domain/profiling/types'
+import { isProfilingSupported } from '../domain/profiling/profilingSupported'
+import { startProfilingContext } from '../domain/profiling/profilingContext'
+import { lazyLoadProfiler } from './lazyLoadProfiler'
+
+export function makeProfilerApi(): ProfilerApi {
+  let profiler: RUMProfiler | undefined
+
+  function onRumStart(
+    lifeCycle: LifeCycle,
+    hooks: Hooks,
+    configuration: RumConfiguration,
+    sessionManager: RumSessionManager,
+    viewHistory: ViewHistory,
+    longTaskContexts: LongTaskContexts,
+    createEncoder: (streamId: DeflateEncoderStreamId) => Encoder
+  ) {
+    const session = sessionManager.findTrackedSession() // Check if the session is tracked.
+
+    if (!session) {
+      // No session tracked, no profiling.
+      // Note: No Profiling context is set at this stage.
+      return
+    }
+
+    // Sampling (sticky sampling based on session id)
+    if (!isSampled(session.id, configuration.profilingSampleRate)) {
+      // No sampling, no profiling.
+      // Note: No Profiling context is set at this stage.
+      return
+    }
+
+    // Listen to events and add the profiling context to them.
+    const profilingContextManager = startProfilingContext(hooks)
+
+    // Browser support check
+    if (!isProfilingSupported()) {
+      profilingContextManager.set({
+        status: 'error',
+        error_reason: 'not-supported-by-browser',
+      })
+      return
+    }
+
+    lazyLoadProfiler()
+      .then((createRumProfiler) => {
+        if (!createRumProfiler) {
+          addTelemetryDebug('[KUBESENSE_SDK] Failed to lazy load the RUM Profiler')
+          profilingContextManager.set({ status: 'error', error_reason: 'failed-to-lazy-load' })
+          return
+        }
+
+        profiler = createRumProfiler(
+          configuration,
+          lifeCycle,
+          sessionManager,
+          profilingContextManager,
+          longTaskContexts,
+          createEncoder,
+          viewHistory,
+          undefined
+        )
+        profiler.start()
+      })
+      .catch(monitorError)
+  }
+
+  return {
+    onRumStart,
+    stop: () => {
+      profiler?.stop().catch(monitorError)
+    },
+  }
+}

package/src/boot/recorderApi.ts

@@ -0,0 +1,124 @@
+import type { DeflateEncoder, DeflateWorker, Telemetry } from '@kubesense/kubesense-browser-core'
+import {
+  canUseEventBridge,
+  noop,
+  BridgeCapability,
+  bridgeSupports,
+  DeflateEncoderStreamId,
+} from '@kubesense/kubesense-browser-core'
+import type {
+  LifeCycle,
+  ViewHistory,
+  RumSessionManager,
+  RecorderApi,
+  RumConfiguration,
+  StartRecordingOptions,
+} from '@kubesense/kubesense-browser-rum-core'
+import { getReplayStats as getReplayStatsImpl } from '../domain/replayStats'
+import type { CreateDeflateWorker } from '../domain/deflate'
+import {
+  createDeflateEncoder,
+  DeflateWorkerStatus,
+  getDeflateWorkerStatus,
+  startDeflateWorker,
+} from '../domain/deflate'
+import { isBrowserSupported } from './isBrowserSupported'
+import type { StartRecording } from './postStartStrategy'
+import { createPostStartStrategy } from './postStartStrategy'
+import { createPreStartStrategy } from './preStartStrategy'
+
+export function makeRecorderApi(
+  loadRecorder: () => Promise<StartRecording | undefined>,
+  createDeflateWorkerImpl?: CreateDeflateWorker
+): RecorderApi {
+  if ((canUseEventBridge() && !bridgeSupports(BridgeCapability.RECORDS)) || !isBrowserSupported()) {
+    return {
+      start: noop,
+      stop: noop,
+      getReplayStats: () => undefined,
+      onRumStart: noop,
+      isRecording: () => false,
+      getSessionReplayLink: () => undefined,
+    }
+  }
+
+  // eslint-disable-next-line prefer-const
+  let { strategy, shouldStartImmediately } = createPreStartStrategy()
+
+  return {
+    start: (options?: StartRecordingOptions) => strategy.start(options),
+    stop: () => strategy.stop(),
+    getSessionReplayLink: () => strategy.getSessionReplayLink(),
+    onRumStart,
+    isRecording: () =>
+      // The worker is started optimistically, meaning we could have started to record but its
+      // initialization fails a bit later. This could happen when:
+      // * the worker URL (blob or plain URL) is blocked by CSP in Firefox only (Chromium and Safari
+      // throw an exception when instantiating the worker, and IE doesn't care about CSP)
+      // * the browser fails to load the worker in case the workerUrl is used
+      // * an unexpected error occurs in the Worker before initialization, ex:
+      //   * a runtime exception collected by monitor()
+      //   * a syntax error notified by the browser via an error event
+      // * the worker is unresponsive for some reason and timeouts
+      //
+      // It is not expected to happen often. Nonetheless, the "replayable" status on RUM events is
+      // an important part of the Kubsesense App:
+      // * If we have a false positive (we set has_replay: true even if no replay data is present),
+      // we might display broken links to the Session Replay player.
+      // * If we have a false negative (we don't set has_replay: true even if replay data is
+      // available), it is less noticeable because no link will be displayed.
+      //
+      // Thus, it is better to have false negative, so let's make sure the worker is correctly
+      // initialized before advertizing that we are recording.
+      //
+      // In the future, when the compression worker will also be used for RUM data, this will be
+      // less important since no RUM event will be sent when the worker fails to initialize.
+      getDeflateWorkerStatus() === DeflateWorkerStatus.Initialized && strategy.isRecording(),
+
+    getReplayStats: (viewId) =>
+      getDeflateWorkerStatus() === DeflateWorkerStatus.Initialized ? getReplayStatsImpl(viewId) : undefined,
+  }
+
+  function onRumStart(
+    lifeCycle: LifeCycle,
+    configuration: RumConfiguration,
+    sessionManager: RumSessionManager,
+    viewHistory: ViewHistory,
+    worker: DeflateWorker | undefined,
+    telemetry: Telemetry
+  ) {
+    let cachedDeflateEncoder: DeflateEncoder | undefined
+
+    function getOrCreateDeflateEncoder() {
+      if (!cachedDeflateEncoder) {
+        worker ??= startDeflateWorker(
+          configuration,
+          'Kubsesense Session Replay',
+          () => {
+            strategy.stop()
+          },
+          createDeflateWorkerImpl
+        )
+
+        if (worker) {
+          cachedDeflateEncoder = createDeflateEncoder(configuration, worker, DeflateEncoderStreamId.REPLAY)
+        }
+      }
+      return cachedDeflateEncoder
+    }
+
+    strategy = createPostStartStrategy(
+      configuration,
+      lifeCycle,
+      sessionManager,
+      viewHistory,
+      loadRecorder,
+      getOrCreateDeflateEncoder,
+      telemetry
+    )
+
+    if (shouldStartImmediately(configuration)) {
+      strategy.start()
+    }
+  }
+}