Introduce CaptureStrategy for buffer and session modes

Author: romtsn

sentry-android-replay/src/main/java/io/sentry/android/replay/ReplayIntegration.kt

@@ -5,37 +5,24 @@ import android.content.Context
 import android.content.res.Configuration
 import android.graphics.Bitmap
 import android.os.Build
-import io.sentry.DateUtils
 import io.sentry.Hint
 import io.sentry.IHub
 import io.sentry.Integration
 import io.sentry.ReplayController
-import io.sentry.ReplayRecording
 import io.sentry.SentryEvent
 import io.sentry.SentryIntegrationPackageStorage
 import io.sentry.SentryLevel.DEBUG
 import io.sentry.SentryLevel.INFO
 import io.sentry.SentryOptions
-import io.sentry.SentryReplayEvent
-import io.sentry.SentryReplayEvent.ReplayType
-import io.sentry.SentryReplayEvent.ReplayType.BUFFER
-import io.sentry.SentryReplayEvent.ReplayType.SESSION
 import io.sentry.android.replay.capture.BufferCaptureStrategy
 import io.sentry.android.replay.capture.CaptureStrategy
 import io.sentry.android.replay.capture.SessionCaptureStrategy
-import io.sentry.android.replay.util.gracefullyShutdown
 import io.sentry.android.replay.util.sample
-import io.sentry.android.replay.util.submitSafely
 import io.sentry.protocol.SentryId
-import io.sentry.rrweb.RRWebMetaEvent
-import io.sentry.rrweb.RRWebVideoEvent
 import io.sentry.transport.ICurrentDateProvider
-import io.sentry.util.FileUtils
 import io.sentry.util.IntegrationUtils.addIntegrationToSdkVersion
 import java.io.Closeable
-import java.io.File
 import java.security.SecureRandom
-import java.util.Date
 import java.util.concurrent.atomic.AtomicBoolean
 
 class ReplayIntegration(
@@ -49,7 +36,6 @@ class ReplayIntegration(
     private val random by lazy { SecureRandom() }
 
     // TODO: probably not everything has to be thread-safe here
-    private val isFullSession = AtomicBoolean(false)
     private val isEnabled = AtomicBoolean(false)
     private val isRecording = AtomicBoolean(false)
     private var captureStrategy: CaptureStrategy? = null
@@ -71,22 +57,9 @@ class ReplayIntegration(
             return
         }
 
-        isFullSession.set(random.sample(options.experimental.sessionReplay.sessionSampleRate))
-        if (!isFullSession.get() &&
-            !options.experimental.sessionReplay.isSessionReplayForErrorsEnabled
-        ) {
-            options.logger.log(INFO, "Session replay is disabled, full session was not sampled and errorSampleRate is not specified")
-            return
-        }
-
         this.hub = hub
         recorder = WindowRecorder(options, this)
         isEnabled.set(true)
-        captureStrategy = if (isFullSession.get()) {
-            SessionCaptureStrategy(options, hub, dateProvider)
-        } else {
-            BufferCaptureStrategy(options, hub, dateProvider, random)
-        }
 
         try {
             context.registerComponentCallbacks(this)
@@ -115,7 +88,19 @@ class ReplayIntegration(
             return
         }
 
+        val isFullSession = random.sample(options.experimental.sessionReplay.sessionSampleRate)
+        if (!isFullSession && !options.experimental.sessionReplay.isSessionReplayForErrorsEnabled) {
+            options.logger.log(INFO, "Session replay is not started, full session was not sampled and errorSampleRate is not specified")
+            return
+        }
+
         recorderConfig = ScreenshotRecorderConfig.from(context, options.experimental.sessionReplay)
+        captureStrategy = if (isFullSession) {
+            SessionCaptureStrategy(options, hub, dateProvider, recorderConfig)
+        } else {
+            BufferCaptureStrategy(options, hub, dateProvider, recorderConfig, random)
+        }
+
         captureStrategy?.start()
         recorder?.startRecording(recorderConfig)
     }
@@ -139,8 +124,12 @@ class ReplayIntegration(
             return
         }
 
-        captureStrategy?.sendReplayForEvent(event, hint)
-        isFullSession.set(true)
+        if (SentryId.EMPTY_ID.equals(captureStrategy?.currentReplayId?.get())) {
+            options.logger.log(DEBUG, "Replay id is not set, not capturing for event %s", event.eventId)
+            return
+        }
+
+        captureStrategy?.sendReplayForEvent(event, hint, onSegmentSent = { captureStrategy?.currentSegment?.getAndIncrement()})
         captureStrategy = captureStrategy?.convert()
     }
 
@@ -158,72 +147,14 @@ class ReplayIntegration(
             return
         }
 
-        val now = dateProvider.currentTimeMillis
-        val currentSegmentTimestamp = segmentTimestamp.get()
-        val segmentId = currentSegment.get()
-        val duration = now - currentSegmentTimestamp.time
-        val replayId = currentReplayId.get()
-        val replayCacheDir = cache?.replayCacheDir
-        val height = recorderConfig.recordingHeight
-        val width = recorderConfig.recordingWidth
-        replayExecutor.submitSafely(options, "$TAG.stop") {
-            // we don't flush the segment, but we still wanna clean up the folder for buffer mode
-            if (isFullSession.get()) {
-                createAndCaptureSegment(duration, currentSegmentTimestamp, replayId, segmentId, height, width)
-            }
-            FileUtils.deleteRecursively(replayCacheDir)
-        }
-
         recorder?.stopRecording()
-        cache?.close()
-        currentSegment.set(0)
-        replayStartTimestamp.set(0)
-        segmentTimestamp.set(null)
-        currentReplayId.set(SentryId.EMPTY_ID)
-        hub?.configureScope { it.replayId = SentryId.EMPTY_ID }
+        captureStrategy?.stop()
         isRecording.set(false)
+        captureStrategy = null
     }
 
     override fun onScreenshotRecorded(bitmap: Bitmap) {
-        // have to do it before submitting, otherwise if the queue is busy, the timestamp won't be
-        // reflecting the exact time of when it was captured
-        val frameTimestamp = dateProvider.currentTimeMillis
-        val height = recorderConfig.recordingHeight
-        val width = recorderConfig.recordingWidth
-        replayExecutor.submitSafely(options, "$TAG.add_frame") {
-            cache?.addFrame(bitmap, frameTimestamp)
-
-            val now = dateProvider.currentTimeMillis
-            if (isFullSession.get() &&
-                (now - segmentTimestamp.get().time >= options.experimental.sessionReplay.sessionSegmentDuration)
-            ) {
-                val currentSegmentTimestamp = segmentTimestamp.get()
-                val segmentId = currentSegment.get()
-                val replayId = currentReplayId.get()
-
-                val videoDuration =
-                    createAndCaptureSegment(
-                        options.experimental.sessionReplay.sessionSegmentDuration,
-                        currentSegmentTimestamp,
-                        replayId,
-                        segmentId,
-                        height,
-                        width
-                    )
-                if (videoDuration != null) {
-                    currentSegment.getAndIncrement()
-                    // set next segment timestamp as close to the previous one as possible to avoid gaps
-                    segmentTimestamp.set(DateUtils.getDateTime(currentSegmentTimestamp.time + videoDuration))
-                }
-            } else if (isFullSession.get() &&
-                (now - replayStartTimestamp.get() >= options.experimental.sessionReplay.sessionDuration)
-            ) {
-                stop()
-                options.logger.log(INFO, "Session replay deadline exceeded (1h), stopping recording")
-            } else if (!isFullSession.get()) {
-                cache?.rotate(now - options.experimental.sessionReplay.errorReplayDuration)
-            }
-        }
+        captureStrategy?.onScreenshotRecorded(bitmap)
     }
 
     override fun close() {
@@ -247,26 +178,10 @@ class ReplayIntegration(
 
         recorder?.stopRecording()
 
-        // TODO: support buffer mode and breadcrumb/rrweb_event
-        if (isFullSession.get()) {
-            val now = dateProvider.currentTimeMillis
-            val currentSegmentTimestamp = segmentTimestamp.get()
-            val segmentId = currentSegment.get()
-            val duration = now - currentSegmentTimestamp.time
-            val replayId = currentReplayId.get()
-            val height = recorderConfig.recordingHeight
-            val width = recorderConfig.recordingWidth
-            replayExecutor.submitSafely(options, "$TAG.onConfigurationChanged") {
-                val videoDuration =
-                    createAndCaptureSegment(duration, currentSegmentTimestamp, replayId, segmentId, height, width)
-                if (videoDuration != null) {
-                    currentSegment.getAndIncrement()
-                }
-            }
-        }
-
         // refresh config based on new device configuration
         recorderConfig = ScreenshotRecorderConfig.from(context, options.experimental.sessionReplay)
+        captureStrategy?.onConfigurationChanged(recorderConfig)
+
         recorder?.startRecording(recorderConfig)
     }
 

sentry-android-replay/src/main/java/io/sentry/android/replay/WindowRecorder.kt

@@ -32,7 +32,9 @@ internal class WindowRecorder(
     private val rootViews = ArrayList<WeakReference<View>>()
     private var recorder: ScreenshotRecorder? = null
     private var capturingTask: ScheduledFuture<*>? = null
-    private val capturer = Executors.newSingleThreadScheduledExecutor(RecorderExecutorServiceThreadFactory())
+    private val capturer by lazy {
+        Executors.newSingleThreadScheduledExecutor(RecorderExecutorServiceThreadFactory())
+    }
 
     private val onRootViewsChangedListener = OnRootViewsChangedListener { root, added ->
         if (added) {

sentry-android-replay/src/main/java/io/sentry/android/replay/capture/BaseCaptureStrategy.kt

@@ -2,16 +2,14 @@ package io.sentry.android.replay.capture
 
 import io.sentry.DateUtils
 import io.sentry.Hint
+import io.sentry.IHub
 import io.sentry.ReplayRecording
-import io.sentry.SentryEvent
 import io.sentry.SentryOptions
 import io.sentry.SentryReplayEvent
 import io.sentry.SentryReplayEvent.ReplayType
 import io.sentry.SentryReplayEvent.ReplayType.SESSION
 import io.sentry.android.replay.ReplayCache
-import io.sentry.android.replay.ReplayIntegration
-import io.sentry.android.replay.ReplayIntegration.Companion
-import io.sentry.android.replay.ReplayIntegration.ReplayExecutorServiceThreadFactory
+import io.sentry.android.replay.ScreenshotRecorderConfig
 import io.sentry.android.replay.util.gracefullyShutdown
 import io.sentry.android.replay.util.submitSafely
 import io.sentry.protocol.SentryId
@@ -22,28 +20,31 @@ import io.sentry.util.FileUtils
 import java.io.File
 import java.util.Date
 import java.util.concurrent.Executors
+import java.util.concurrent.ScheduledExecutorService
 import java.util.concurrent.ThreadFactory
 import java.util.concurrent.atomic.AtomicInteger
 import java.util.concurrent.atomic.AtomicLong
 import java.util.concurrent.atomic.AtomicReference
 
 abstract class BaseCaptureStrategy(
     private val options: SentryOptions,
-    private val dateProvider: ICurrentDateProvider
+    private val dateProvider: ICurrentDateProvider,
+    protected var recorderConfig: ScreenshotRecorderConfig,
+    executor: ScheduledExecutorService? = null
 ) : CaptureStrategy {
 
     internal companion object {
         private const val TAG = "CaptureStrategy"
     }
 
     protected var cache: ReplayCache? = null
-    protected val currentReplayId = AtomicReference(SentryId.EMPTY_ID)
     protected val segmentTimestamp = AtomicReference<Date>()
     protected val replayStartTimestamp = AtomicLong()
-    protected val currentSegment = AtomicInteger(0)
+    override val currentReplayId = AtomicReference(SentryId.EMPTY_ID)
+    override val currentSegment = AtomicInteger(0)
 
-    protected val replayExecutor by lazy {
-        Executors.newSingleThreadScheduledExecutor(ReplayExecutorServiceThreadFactory())
+    protected val replayExecutor: ScheduledExecutorService by lazy {
+        executor ?: Executors.newSingleThreadScheduledExecutor(ReplayExecutorServiceThreadFactory())
     }
 
     override fun start(segmentId: Int, replayId: SentryId, cleanupOldReplays: Boolean) {
@@ -81,26 +82,35 @@ abstract class BaseCaptureStrategy(
         segmentTimestamp.set(DateUtils.getCurrentDateTime())
     }
 
-    protected fun createAndCaptureSegment(
+    override fun pause() = Unit
+
+    override fun stop() {
+        cache?.close()
+        currentSegment.set(0)
+        replayStartTimestamp.set(0)
+        segmentTimestamp.set(null)
+        currentReplayId.set(SentryId.EMPTY_ID)
+    }
+
+    protected fun createSegment(
         duration: Long,
         currentSegmentTimestamp: Date,
         replayId: SentryId,
         segmentId: Int,
         height: Int,
         width: Int,
         replayType: ReplayType = SESSION,
-        hint: Hint? = null
-    ): Long? {
+    ): ReplaySegment {
         val generatedVideo = cache?.createVideoOf(
             duration,
             currentSegmentTimestamp.time,
             segmentId,
             height,
             width
-        ) ?: return null
+        ) ?: return ReplaySegment.Failed
 
         val (video, frameCount, videoDuration) = generatedVideo
-        captureReplay(
+        return buildReplay(
             video,
             replayId,
             currentSegmentTimestamp,
@@ -110,12 +120,10 @@ abstract class BaseCaptureStrategy(
             frameCount,
             videoDuration,
             replayType,
-            hint
         )
-        return videoDuration
     }
 
-    private fun captureReplay(
+    private fun buildReplay(
         video: File,
         currentReplayId: SentryId,
         segmentTimestamp: Date,
@@ -125,16 +133,13 @@ abstract class BaseCaptureStrategy(
         frameCount: Int,
         duration: Long,
         replayType: ReplayType,
-        hint: Hint? = null
-    ) {
+    ): ReplaySegment {
         val replay = SentryReplayEvent().apply {
             eventId = currentReplayId
             replayId = currentReplayId
             this.segmentId = segmentId
             this.timestamp = DateUtils.getDateTime(segmentTimestamp.time + duration)
-            if (segmentId == 0) {
-                replayStartTimestamp = segmentTimestamp
-            }
+            replayStartTimestamp = segmentTimestamp
             this.replayType = replayType
             videoFile = video
         }
@@ -163,7 +168,11 @@ abstract class BaseCaptureStrategy(
             )
         }
 
-//        hub?.captureReplay(replay, (hint ?: Hint()).apply { replayRecording = recording })
+        return ReplaySegment.Created(videoDuration = duration, replay = replay, recording = recording)
+    }
+
+    override fun onConfigurationChanged(recorderConfig: ScreenshotRecorderConfig) {
+        this.recorderConfig = recorderConfig
     }
 
     override fun close() {
@@ -178,4 +187,26 @@ abstract class BaseCaptureStrategy(
             return ret
         }
     }
+
+    protected sealed class ReplaySegment {
+        object Failed : ReplaySegment()
+        data class Created(
+            val videoDuration: Long,
+            val replay: SentryReplayEvent,
+            val recording: ReplayRecording
+        ): ReplaySegment() {
+            fun capture(hub: IHub?, hint: Hint = Hint()) {
+                hub?.captureReplay(replay, hint.apply { replayRecording = recording })
+            }
+
+            fun setSegmentId(segmentId: Int) {
+                replay.segmentId = segmentId
+                recording.payload?.forEach {
+                    when (it) {
+                        is RRWebVideoEvent -> it.segmentId = segmentId
+                    }
+                }
+            }
+        }
+    }
 }