[SR] GA Session replay

CHANGELOG.md

@@ -2,15 +2,45 @@
 
 ## Unreleased
 
+### Features
+
+- Session Replay GA ([#4017](https://github.com/getsentry/sentry-java/pull/4017))
+
+To enable Replay use the `sessionReplay.sessionSampleRate` or `sessionReplay.errorSampleRate` options.
+
+  ```kotlin
+  import io.sentry.SentryReplayOptions
+  import io.sentry.android.core.SentryAndroid
+
+  SentryAndroid.init(context) { options ->
+
+    options.sessionReplay.sessionSampleRate = 1.0
+    options.sessionReplay.errorSampleRate = 1.0
+
+    // To change default redaction behavior (defaults to true)
+    options.sessionReplay.redactAllImages = true
+    options.sessionReplay.redactAllText = true
+
+    // To change quality of the recording (defaults to MEDIUM)
+    options.sessionReplay.quality = SentryReplayOptions.SentryReplayQuality.MEDIUM // (LOW|MEDIUM|HIGH)
+  }
+  ```
+
 ### Fixes
 
 - Fix warm start detection ([#3937](https://github.com/getsentry/sentry-java/pull/3937))
+- Session Replay: Reduce memory allocations, disk space consumption, and payload size ([#4016](https://github.com/getsentry/sentry-java/pull/4016))
+- Session Replay: Do not try to encode corrupted frames multiple times ([#4016](https://github.com/getsentry/sentry-java/pull/4016))
 
 ### Internal
 
 - Session Replay: Allow overriding `SdkVersion` for replay events ([#4014](https://github.com/getsentry/sentry-java/pull/4014))
 - Session Replay: Send replay options as tags ([#4015](https://github.com/getsentry/sentry-java/pull/4015))
 
+### Breaking changes
+
+- Session Replay options were moved from under `experimental` to the main `options` object ([#4017](https://github.com/getsentry/sentry-java/pull/4017))
+
 ## 7.19.1
 
 ### Fixes

sentry-android-core/src/main/java/io/sentry/android/core/ManifestMetadataReader.java

@@ -399,28 +399,26 @@ static void applyMetadata(
         options.setEnableMetrics(
             readBool(metadata, logger, ENABLE_METRICS, options.isEnableMetrics()));
 
-        if (options.getExperimental().getSessionReplay().getSessionSampleRate() == null) {
+        if (options.getSessionReplay().getSessionSampleRate() == null) {
           final Double sessionSampleRate =
               readDouble(metadata, logger, REPLAYS_SESSION_SAMPLE_RATE);
           if (sessionSampleRate != -1) {
-            options.getExperimental().getSessionReplay().setSessionSampleRate(sessionSampleRate);
+            options.getSessionReplay().setSessionSampleRate(sessionSampleRate);
           }
         }
 
-        if (options.getExperimental().getSessionReplay().getOnErrorSampleRate() == null) {
+        if (options.getSessionReplay().getOnErrorSampleRate() == null) {
           final Double onErrorSampleRate = readDouble(metadata, logger, REPLAYS_ERROR_SAMPLE_RATE);
           if (onErrorSampleRate != -1) {
-            options.getExperimental().getSessionReplay().setOnErrorSampleRate(onErrorSampleRate);
+            options.getSessionReplay().setOnErrorSampleRate(onErrorSampleRate);
           }
         }
 
         options
-            .getExperimental()
             .getSessionReplay()
             .setMaskAllText(readBool(metadata, logger, REPLAYS_MASK_ALL_TEXT, true));
 
         options
-            .getExperimental()
             .getSessionReplay()
             .setMaskAllImages(readBool(metadata, logger, REPLAYS_MASK_ALL_IMAGES, true));
       }

sentry-android-core/src/test/java/io/sentry/android/core/ManifestMetadataReaderTest.kt

@@ -1459,22 +1459,22 @@ class ManifestMetadataReaderTest {
         ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
 
         // Assert
-        assertEquals(expectedSampleRate.toDouble(), fixture.options.experimental.sessionReplay.onErrorSampleRate)
+        assertEquals(expectedSampleRate.toDouble(), fixture.options.sessionReplay.onErrorSampleRate)
     }
 
     @Test
     fun `applyMetadata does not override replays onErrorSampleRate from options`() {
         // Arrange
         val expectedSampleRate = 0.99f
-        fixture.options.experimental.sessionReplay.onErrorSampleRate = expectedSampleRate.toDouble()
+        fixture.options.sessionReplay.onErrorSampleRate = expectedSampleRate.toDouble()
         val bundle = bundleOf(ManifestMetadataReader.REPLAYS_ERROR_SAMPLE_RATE to 0.1f)
         val context = fixture.getContext(metaData = bundle)
 
         // Act
         ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
 
         // Assert
-        assertEquals(expectedSampleRate.toDouble(), fixture.options.experimental.sessionReplay.onErrorSampleRate)
+        assertEquals(expectedSampleRate.toDouble(), fixture.options.sessionReplay.onErrorSampleRate)
     }
 
     @Test
@@ -1486,7 +1486,7 @@ class ManifestMetadataReaderTest {
         ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
 
         // Assert
-        assertNull(fixture.options.experimental.sessionReplay.onErrorSampleRate)
+        assertNull(fixture.options.sessionReplay.onErrorSampleRate)
     }
 
     @Test
@@ -1499,8 +1499,8 @@ class ManifestMetadataReaderTest {
         ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
 
         // Assert
-        assertTrue(fixture.options.experimental.sessionReplay.unmaskViewClasses.contains(SentryReplayOptions.IMAGE_VIEW_CLASS_NAME))
-        assertTrue(fixture.options.experimental.sessionReplay.unmaskViewClasses.contains(SentryReplayOptions.TEXT_VIEW_CLASS_NAME))
+        assertTrue(fixture.options.sessionReplay.unmaskViewClasses.contains(SentryReplayOptions.IMAGE_VIEW_CLASS_NAME))
+        assertTrue(fixture.options.sessionReplay.unmaskViewClasses.contains(SentryReplayOptions.TEXT_VIEW_CLASS_NAME))
     }
 
     @Test
@@ -1512,8 +1512,8 @@ class ManifestMetadataReaderTest {
         ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
 
         // Assert
-        assertTrue(fixture.options.experimental.sessionReplay.maskViewClasses.contains(SentryReplayOptions.IMAGE_VIEW_CLASS_NAME))
-        assertTrue(fixture.options.experimental.sessionReplay.maskViewClasses.contains(SentryReplayOptions.TEXT_VIEW_CLASS_NAME))
+        assertTrue(fixture.options.sessionReplay.maskViewClasses.contains(SentryReplayOptions.IMAGE_VIEW_CLASS_NAME))
+        assertTrue(fixture.options.sessionReplay.maskViewClasses.contains(SentryReplayOptions.TEXT_VIEW_CLASS_NAME))
     }
 
     @Test
@@ -1562,7 +1562,7 @@ class ManifestMetadataReaderTest {
         assertEquals(expectedSampleRate.toDouble(), fixture.options.sampleRate)
         assertEquals(expectedSampleRate.toDouble(), fixture.options.tracesSampleRate)
         assertEquals(expectedSampleRate.toDouble(), fixture.options.profilesSampleRate)
-        assertEquals(expectedSampleRate.toDouble(), fixture.options.experimental.sessionReplay.sessionSampleRate)
-        assertEquals(expectedSampleRate.toDouble(), fixture.options.experimental.sessionReplay.onErrorSampleRate)
+        assertEquals(expectedSampleRate.toDouble(), fixture.options.sessionReplay.sessionSampleRate)
+        assertEquals(expectedSampleRate.toDouble(), fixture.options.sessionReplay.onErrorSampleRate)
     }
 }

sentry-android-core/src/test/java/io/sentry/android/core/SentryAndroidTest.kt

@@ -371,7 +371,7 @@ class SentryAndroidTest {
                 options.release = "prod"
                 options.dsn = "https://[email protected]/123"
                 options.isEnableAutoSessionTracking = true
-                options.experimental.sessionReplay.onErrorSampleRate = 1.0
+                options.sessionReplay.onErrorSampleRate = 1.0
                 optionsConfig(options)
             }
 

sentry-android-integration-tests/sentry-uitest-android/src/androidTest/java/io/sentry/uitest/android/ReplayTest.kt

@@ -65,7 +65,7 @@ class ReplayTest : BaseUiTest() {
         activityScenario.moveToState(Lifecycle.State.RESUMED)
 
         initSentry {
-            it.experimental.sessionReplay.sessionSampleRate = 1.0
+            it.sessionReplay.sessionSampleRate = 1.0
 
             it.beforeSendReplay =
                 SentryOptions.BeforeSendReplayCallback { event, _ ->

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

@@ -85,7 +85,7 @@ public class ReplayCache(
             it.createNewFile()
         }
         screenshot.outputStream().use {
-            bitmap.compress(JPEG, 80, it)
+            bitmap.compress(JPEG, options.sessionReplay.quality.screenshotQuality, it)
             it.flush()
         }
 
@@ -162,7 +162,7 @@ public class ReplayCache(
 
         val step = 1000 / frameRate.toLong()
         var frameCount = 0
-        var lastFrame: ReplayFrame = frames.first()
+        var lastFrame: ReplayFrame? = frames.first()
         for (timestamp in from until (from + (duration)) step step) {
             val iter = frames.iterator()
             while (iter.hasNext()) {
@@ -182,6 +182,12 @@ public class ReplayCache(
             // to respect the video duration
             if (encode(lastFrame)) {
                 frameCount++
+            } else if (lastFrame != null) {
+                // if we failed to encode the frame, we delete the screenshot right away as the
+                // likelihood of it being able to be encoded later is low
+                deleteFile(lastFrame.screenshot)
+                frames.remove(lastFrame)
+                lastFrame = null
             }
         }
 
@@ -206,7 +212,10 @@ public class ReplayCache(
         return GeneratedVideo(videoFile, frameCount, videoDuration)
     }
 
-    private fun encode(frame: ReplayFrame): Boolean {
+    private fun encode(frame: ReplayFrame?): Boolean {
+        if (frame == null) {
+            return false
+        }
         return try {
             val bitmap = BitmapFactory.decodeFile(frame.screenshot.absolutePath)
             synchronized(encoderLock) {

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

@@ -118,8 +118,8 @@ public class ReplayIntegration(
             return
         }
 
-        if (!options.experimental.sessionReplay.isSessionReplayEnabled &&
-            !options.experimental.sessionReplay.isSessionReplayForErrorsEnabled
+        if (!options.sessionReplay.isSessionReplayEnabled &&
+            !options.sessionReplay.isSessionReplayForErrorsEnabled
         ) {
             options.logger.log(INFO, "Session replay is disabled, no sample rate specified")
             return
@@ -132,7 +132,7 @@ public class ReplayIntegration(
 
         options.connectionStatusProvider.addConnectionStatusObserver(this)
         hub.rateLimiter?.addRateLimitObserver(this)
-        if (options.experimental.sessionReplay.isTrackOrientationChange) {
+        if (options.sessionReplay.isTrackOrientationChange) {
             try {
                 context.registerComponentCallbacks(this)
             } catch (e: Throwable) {
@@ -167,13 +167,13 @@ public class ReplayIntegration(
             return
         }
 
-        val isFullSession = random.sample(options.experimental.sessionReplay.sessionSampleRate)
-        if (!isFullSession && !options.experimental.sessionReplay.isSessionReplayForErrorsEnabled) {
+        val isFullSession = random.sample(options.sessionReplay.sessionSampleRate)
+        if (!isFullSession && !options.sessionReplay.isSessionReplayForErrorsEnabled) {
             options.logger.log(INFO, "Session replay is not started, full session was not sampled and onErrorSampleRate is not specified")
             return
         }
 
-        val recorderConfig = recorderConfigProvider?.invoke(false) ?: ScreenshotRecorderConfig.from(context, options.experimental.sessionReplay)
+        val recorderConfig = recorderConfigProvider?.invoke(false) ?: ScreenshotRecorderConfig.from(context, options.sessionReplay)
         captureStrategy = replayCaptureStrategyProvider?.invoke(isFullSession) ?: if (isFullSession) {
             SessionCaptureStrategy(options, hub, dateProvider, replayExecutor, replayCacheProvider)
         } else {
@@ -264,7 +264,7 @@ public class ReplayIntegration(
 
         options.connectionStatusProvider.removeConnectionStatusObserver(this)
         hub?.rateLimiter?.removeRateLimitObserver(this)
-        if (options.experimental.sessionReplay.isTrackOrientationChange) {
+        if (options.sessionReplay.isTrackOrientationChange) {
             try {
                 context.unregisterComponentCallbacks(this)
             } catch (ignored: Throwable) {
@@ -285,7 +285,7 @@ public class ReplayIntegration(
         recorder?.stop()
 
         // refresh config based on new device configuration
-        val recorderConfig = recorderConfigProvider?.invoke(true) ?: ScreenshotRecorderConfig.from(context, options.experimental.sessionReplay)
+        val recorderConfig = recorderConfigProvider?.invoke(true) ?: ScreenshotRecorderConfig.from(context, options.sessionReplay)
         captureStrategy?.onConfigurationChanged(recorderConfig)
 
         recorder?.start(recorderConfig)

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

@@ -3,7 +3,6 @@ package io.sentry.android.replay
 import android.annotation.TargetApi
 import android.content.Context
 import android.graphics.Bitmap
-import android.graphics.Bitmap.Config.ARGB_8888
 import android.graphics.Canvas
 import android.graphics.Color
 import android.graphics.Matrix
@@ -54,9 +53,14 @@ internal class ScreenshotRecorder(
         Bitmap.createBitmap(
             1,
             1,
-            Bitmap.Config.ARGB_8888
+            Bitmap.Config.RGB_565
         )
     }
+    private val screenshot = Bitmap.createBitmap(
+        config.recordingWidth,
+        config.recordingHeight,
+        Bitmap.Config.RGB_565
+    )
     private val singlePixelBitmapCanvas: Canvas by lazy(NONE) { Canvas(singlePixelBitmap) }
     private val prescaledMatrix by lazy(NONE) {
         Matrix().apply {
@@ -65,22 +69,18 @@ internal class ScreenshotRecorder(
     }
     private val contentChanged = AtomicBoolean(false)
     private val isCapturing = AtomicBoolean(true)
-    private var lastScreenshot: Bitmap? = null
+    private val lastCaptureSuccessful = AtomicBoolean(false)
 
     fun capture() {
         if (!isCapturing.get()) {
             options.logger.log(DEBUG, "ScreenshotRecorder is paused, not capturing screenshot")
             return
         }
 
-        if (!contentChanged.get() && lastScreenshot != null && !lastScreenshot!!.isRecycled) {
+        if (!contentChanged.get() && lastCaptureSuccessful.get()) {
             options.logger.log(DEBUG, "Content hasn't changed, repeating last known frame")
 
-            lastScreenshot?.let {
-                screenshotRecorderCallback?.onScreenshotRecorded(
-                    it.copy(ARGB_8888, false)
-                )
-            }
+            screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
             return
         }
 
@@ -96,38 +96,33 @@ internal class ScreenshotRecorder(
             return
         }
 
-        val bitmap = Bitmap.createBitmap(
-            config.recordingWidth,
-            config.recordingHeight,
-            Bitmap.Config.ARGB_8888
-        )
-
         // postAtFrontOfQueue to ensure the view hierarchy and bitmap are ase close in-sync as possible
         mainLooperHandler.post {
             try {
                 contentChanged.set(false)
                 PixelCopy.request(
                     window,
-                    bitmap,
+                    screenshot,
                     { copyResult: Int ->
                         if (copyResult != PixelCopy.SUCCESS) {
                             options.logger.log(INFO, "Failed to capture replay recording: %d", copyResult)
-                            bitmap.recycle()
+                            lastCaptureSuccessful.set(false)
                             return@request
                         }
 
                         // TODO: handle animations with heuristics (e.g. if we fall under this condition 2 times in a row, we should capture)
                         if (contentChanged.get()) {
                             options.logger.log(INFO, "Failed to determine view hierarchy, not capturing")
-                            bitmap.recycle()
+                            lastCaptureSuccessful.set(false)
                             return@request
                         }
 
+                        // TODO: disableAllMasking here and dont traverse?
                         val viewHierarchy = ViewHierarchyNode.fromView(root, null, 0, options)
                         root.traverse(viewHierarchy, options)
 
                         recorder.submitSafely(options, "screenshot_recorder.mask") {
-                            val canvas = Canvas(bitmap)
+                            val canvas = Canvas(screenshot)
                             canvas.setMatrix(prescaledMatrix)
                             viewHierarchy.traverse { node ->
                                 if (node.shouldMask && (node.width > 0 && node.height > 0)) {
@@ -141,7 +136,7 @@ internal class ScreenshotRecorder(
                                     val (visibleRects, color) = when (node) {
                                         is ImageViewHierarchyNode -> {
                                             listOf(node.visibleRect) to
-                                                bitmap.dominantColorForRect(node.visibleRect)
+                                                screenshot.dominantColorForRect(node.visibleRect)
                                         }
 
                                         is TextViewHierarchyNode -> {
@@ -168,20 +163,16 @@ internal class ScreenshotRecorder(
                                 return@traverse true
                             }
 
-                            val screenshot = bitmap.copy(ARGB_8888, false)
                             screenshotRecorderCallback?.onScreenshotRecorded(screenshot)
-                            lastScreenshot?.recycle()
-                            lastScreenshot = screenshot
+                            lastCaptureSuccessful.set(true)
                             contentChanged.set(false)
-
-                            bitmap.recycle()
                         }
                     },
                     mainLooperHandler.handler
                 )
             } catch (e: Throwable) {
                 options.logger.log(WARNING, "Failed to capture replay recording", e)
-                bitmap.recycle()
+                lastCaptureSuccessful.set(false)
             }
         }
     }
@@ -226,7 +217,7 @@ internal class ScreenshotRecorder(
     fun close() {
         unbind(rootView?.get())
         rootView?.clear()
-        lastScreenshot?.recycle()
+        screenshot.recycle()
         isCapturing.set(false)
     }