redact screenshots via view hierarchy

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Enhancements
 
 - Cache parsed DSN ([#2365](https://github.com/getsentry/sentry-dart/pull/2365))
+- Switching from traditional screenshot to view hierarchy for screenshots which allows redacting ([#2361](https://github.com/getsentry/sentry-dart/pull/2361))
 
 ## 8.10.0-beta.2
 

flutter/lib/sentry_flutter.dart

@@ -9,10 +9,11 @@ export 'src/navigation/sentry_navigator_observer.dart';
 export 'src/sentry_flutter.dart';
 export 'src/sentry_flutter_options.dart';
 export 'src/sentry_replay_options.dart';
+export 'src/sentry_privacy_options.dart';
 export 'src/flutter_sentry_attachment.dart';
 export 'src/sentry_asset_bundle.dart' show SentryAssetBundle;
 export 'src/integrations/on_error_integration.dart';
-export 'src/replay/masking_config.dart' show SentryMaskingDecision;
+export 'src/screenshot/masking_config.dart' show SentryMaskingDecision;
 export 'src/screenshot/sentry_mask_widget.dart';
 export 'src/screenshot/sentry_unmask_widget.dart';
 export 'src/screenshot/sentry_screenshot_widget.dart';

flutter/lib/src/event_processor/screenshot_event_processor.dart

@@ -1,12 +1,12 @@
 import 'dart:async';
-import 'dart:math';
 import 'dart:typed_data';
 import 'dart:ui';
 
 import 'package:sentry/sentry.dart';
+import '../screenshot/recorder.dart';
+import '../screenshot/recorder_config.dart';
 import '../screenshot/sentry_screenshot_widget.dart';
 import '../sentry_flutter_options.dart';
-import 'package:flutter/rendering.dart';
 import '../renderer/renderer.dart';
 import 'package:flutter/widgets.dart' as widget;
 
@@ -30,7 +30,7 @@
         _hasSentryScreenshotWidget) {
       return event;
     }
-    final beforeScreenshot = _options.beforeScreenshot;
+    final beforeScreenshot = _options.screenshot.beforeScreenshot;
     if (beforeScreenshot != null) {
       try {
         final result = beforeScreenshot(event, hint: hint);
@@ -67,91 +67,43 @@
       return event;
     }
 
-    if (_options.attachScreenshotOnlyWhenResumed &&
+    if (_options.screenshot.attachScreenshotOnlyWhenResumed &&
         widget.WidgetsBinding.instance.lifecycleState !=
             AppLifecycleState.resumed) {
       _options.logger(SentryLevel.debug,
           'Only attaching screenshots when application state is resumed.');
       return event;
     }
 
-    final bytes = await _createScreenshot();
-    if (bytes != null) {
-      hint.screenshot = SentryAttachment.fromScreenshotData(bytes);
-    }
-    return event;
-  }
+    // ignore: deprecated_member_use
+    var recorder = ScreenshotRecorder(
+        ScreenshotRecorderConfig(
+            quality: _options.screenshot.screenshotQuality),
+        _options);
 
-  Future<Uint8List?> _createScreenshot() async {
-    try {
-      final renderObject =
-          sentryScreenshotWidgetGlobalKey.currentContext?.findRenderObject();
-      if (renderObject is RenderRepaintBoundary) {
-        // ignore: deprecated_member_use
-        final pixelRatio = window.devicePixelRatio;
-        var imageResult = _getImage(renderObject, pixelRatio);
-        Image image;
-        if (imageResult is Future<Image>) {
-          image = await imageResult;
-        } else {
-          image = imageResult;
-        }
-        // At the time of writing there's no other image format available which
-        // Sentry understands.
+    Uint8List? _screenshotData;
 
-        if (image.width == 0 || image.height == 0) {
-          _options.logger(SentryLevel.debug,
-              'View\'s width and height is zeroed, not taking screenshot.');
-          return null;
-        }
-
-        final targetResolution = _options.screenshotQuality.targetResolution();
-        if (targetResolution != null) {
-          var ratioWidth = targetResolution / image.width;
-          var ratioHeight = targetResolution / image.height;
-          var ratio = min(ratioWidth, ratioHeight);
-          if (ratio > 0.0 && ratio < 1.0) {
-            imageResult = _getImage(renderObject, ratio * pixelRatio);
-            if (imageResult is Future<Image>) {
-              image = await imageResult;
-            } else {
-              image = imageResult;
-            }
-          }
-        }
-        final byteData = await image.toByteData(format: ImageByteFormat.png);
+    await recorder.capture((Image image) async {
+      _screenshotData = await _convertImageToUint8List(image);
+    });
 
-        final bytes = byteData?.buffer.asUint8List();
-        if (bytes?.isNotEmpty == true) {
-          return bytes;
-        } else {
-          _options.logger(SentryLevel.debug,
-              'Screenshot is 0 bytes, not attaching the image.');
-          return null;
-        }
-      }
-    } catch (exception, stackTrace) {
-      _options.logger(
-        SentryLevel.error,
-        'Taking screenshot failed.',
-        exception: exception,
-        stackTrace: stackTrace,
-      );
-      if (_options.automatedTestMode) {
-        rethrow;
-      }
+    if (_screenshotData != null) {
+      hint.screenshot = SentryAttachment.fromScreenshotData(_screenshotData!);
     }
-    return null;
+
+    return event;
   }
 
-  FutureOr<Image> _getImage(
-      RenderRepaintBoundary repaintBoundary, double pixelRatio) {
-    // This one is a hack to use https://api.flutter.dev/flutter/rendering/RenderRepaintBoundary/toImage.html on versions older than 3.7 and https://api.flutter.dev/flutter/rendering/RenderRepaintBoundary/toImageSync.html on versions equal or newer than 3.7
-    try {
-      return (repaintBoundary as dynamic).toImageSync(pixelRatio: pixelRatio)
-          as Image;
-    } on NoSuchMethodError catch (_) {
-      return repaintBoundary.toImage(pixelRatio: pixelRatio);
+  Future<Uint8List?> _convertImageToUint8List(Image image) async {
+    final byteData = await image.toByteData(format: ImageByteFormat.png);
+
+    final bytes = byteData?.buffer.asUint8List();
+    if (bytes?.isNotEmpty == true) {
+      return bytes;
+    } else {
+      _options.logger(
+          SentryLevel.debug, 'Screenshot is 0 bytes, not attaching the image.');
+      return null;
     }
   }
 }

flutter/lib/src/integrations/screenshot_integration.dart

@@ -3,14 +3,14 @@ import '../event_processor/screenshot_event_processor.dart';
 import '../sentry_flutter_options.dart';
 
 /// Adds [ScreenshotEventProcessor] to options event processors if
-/// [SentryFlutterOptions.attachScreenshot] is true
+/// [SentryFlutterOptions.screenshot.attachScreenshot] is true
 class ScreenshotIntegration implements Integration<SentryFlutterOptions> {
   SentryFlutterOptions? _options;
   ScreenshotEventProcessor? _screenshotEventProcessor;
 
   @override
   void call(Hub hub, SentryFlutterOptions options) {
-    if (options.attachScreenshot) {
+    if (options.screenshot.attachScreenshot) {
       _options = options;
       final screenshotEventProcessor = ScreenshotEventProcessor(options);
       options.addEventProcessor(screenshotEventProcessor);

flutter/lib/src/native/cocoa/sentry_native_cocoa.dart

@@ -6,9 +6,9 @@ import 'package:meta/meta.dart';
 
 import '../../../sentry_flutter.dart';
 import '../../event_processor/replay_event_processor.dart';
+import '../../screenshot/recorder.dart';
+import '../../screenshot/recorder_config.dart';
 import '../../replay/integration.dart';
-import '../../replay/recorder.dart';
-import '../../replay/recorder_config.dart';
 import '../sentry_native_channel.dart';
 import 'binding.dart' as cocoa;
 

flutter/lib/src/native/java/sentry_native_java.dart

@@ -7,7 +7,7 @@ import '../../../sentry_flutter.dart';
 import '../../event_processor/replay_event_processor.dart';
 import '../../replay/integration.dart';
 import '../../replay/scheduled_recorder.dart';
-import '../../replay/recorder_config.dart';
+import '../../replay/scheduled_recorder_config.dart';
 import '../sentry_native_channel.dart';
 
 // Note: currently this doesn't do anything. Later, it shall be used with

flutter/lib/src/replay/scheduled_recorder.dart

@@ -2,10 +2,10 @@ import 'dart:async';
 import 'dart:ui';
 
 import 'package:meta/meta.dart';
+import 'scheduled_recorder_config.dart';
 
 import '../../sentry_flutter.dart';
-import 'recorder.dart';
-import 'recorder_config.dart';
+import '../screenshot/recorder.dart';
 import 'scheduler.dart';
 
 @internal

flutter/lib/src/replay/scheduled_recorder_config.dart

@@ -0,0 +1,11 @@
+import '../screenshot/recorder_config.dart';
+
+class ScheduledScreenshotRecorderConfig extends ScreenshotRecorderConfig {
+  final int frameRate;
+
+  const ScheduledScreenshotRecorderConfig({
+    super.width,
+    super.height,
+    required this.frameRate,
+  });
+}

flutter/lib/src/replay/recorder.dart → flutter/lib/src/screenshot/recorder.dart

@@ -5,6 +5,7 @@ import 'package:flutter/rendering.dart';
 import 'package:meta/meta.dart';
 
 import '../../sentry_flutter.dart';
+import 'masking_config.dart';
 import 'recorder_config.dart';
 import 'widget_filter.dart';
 
@@ -21,7 +22,11 @@ class ScreenshotRecorder {
   bool warningLogged = false;
 
   ScreenshotRecorder(this.config, this.options) {
-    final maskingConfig = options.experimental.replay.buildMaskingConfig();
+    /// TODO: Rewrite when default redaction value are synced with SS & SR
+    final SentryMaskingConfig maskingConfig =
+        (options.experimental.privacy ?? SentryPrivacyOptions())
+            .buildMaskingConfig();
+
     if (maskingConfig.length > 0) {
       _widgetFilter = WidgetFilter(maskingConfig, options.logger);
     }
@@ -82,12 +87,16 @@ class ScreenshotRecorder {
       final picture = recorder.endRecording();
 
       try {
-        final finalImage = await picture.toImage(
-            (srcWidth * pixelRatio).round(), (srcHeight * pixelRatio).round());
+        Image finalImage;
+        final targetHeight =
+            config.quality.calculateHeight(srcWidth.toInt(), srcHeight.toInt());
+        final targetWidth =
+            config.quality.calculateWidth(srcWidth.toInt(), srcHeight.toInt());
+        finalImage = await picture.toImage(targetWidth, targetHeight);
         try {
           await callback(finalImage);
         } finally {
-          finalImage.dispose();
+          finalImage.dispose(); // image needs to be disposed manually
         }
       } finally {
         picture.dispose();

flutter/lib/src/replay/recorder_config.dart → flutter/lib/src/screenshot/recorder_config.dart

@@ -2,12 +2,19 @@ import 'dart:math';
 
 import 'package:meta/meta.dart';
 
+import '../../sentry_flutter.dart';
+
 @internal
 class ScreenshotRecorderConfig {
   final int? width;
   final int? height;
+  final SentryScreenshotQuality quality;
 
-  const ScreenshotRecorderConfig({this.width, this.height});
+  const ScreenshotRecorderConfig({
+    this.width,
+    this.height,
+    this.quality = SentryScreenshotQuality.full,
+  });
 
   double getPixelRatio(double srcWidth, double srcHeight) {
     assert((width == null) == (height == null));
@@ -17,13 +24,3 @@ class ScreenshotRecorderConfig {
     return min(width! / srcWidth, height! / srcHeight);
   }
 }
-
-class ScheduledScreenshotRecorderConfig extends ScreenshotRecorderConfig {
-  final int frameRate;
-
-  const ScheduledScreenshotRecorderConfig({
-    super.width,
-    super.height,
-    required this.frameRate,
-  });
-}

flutter/lib/src/screenshot/sentry_screenshot_quality.dart

@@ -1,3 +1,5 @@
+import 'package:meta/meta.dart';
+
 /// The quality of the attached screenshot
 enum SentryScreenshotQuality {
   full,
@@ -17,4 +19,32 @@ enum SentryScreenshotQuality {
         return 854;
     }
   }
+
+  @internal
+  int calculateHeight(int width, int height) {
+    if (this == SentryScreenshotQuality.full) {
+      return height;
+    } else {
+      if (height > width) {
+        return targetResolution()!;
+      } else {
+        var ratio = targetResolution()! / width;
+        return (height * ratio).round();
+      }
+    }
+  }
+
+  @internal
+  int calculateWidth(int width, int height) {
+    if (this == SentryScreenshotQuality.full) {
+      return width;
+    } else {
+      if (width > height) {
+        return targetResolution()!;
+      } else {
+        var ratio = targetResolution()! / height;
+        return (width * ratio).round();
+      }
+    }
+  }
 }

flutter/lib/src/sentry_flutter.dart

@@ -99,6 +99,8 @@
       // ignore: invalid_use_of_internal_member
       runZonedGuardedOnError: runZonedGuardedOnError,
     );
+    // TODO: Remove when we synced SS and SR configurations and have a single default configuration
+    _setRedactionOptions(options);
 
     if (_native != null) {
       // ignore: invalid_use_of_internal_member
@@ -243,6 +245,27 @@
     options.sdk = sdk;
   }
 
+  /// Screen redaction was previously introduced with the SessionReplay feature.
+  /// Screen redaction is enabled by default for SessionReplay.
+  /// As we also to use this feature for Screenshot, which previously was not
+  /// capable of redacting the screenshot, we need to disable redaction for Screenshot by default
+  /// so we don`t break the existing behavior.
+  /// As we have only one central place to configure the redaction,
+  /// we need to set the redaction options to full fill the above default settings.
+  /// The plan is to unify this behaviour with the next major release.
+  static void _setRedactionOptions(SentryFlutterOptions options) {
+    if (options.experimental.privacy != null) {
+      return;
+    } else if (options.screenshot.attachScreenshot == true &&
+        !options.experimental.replay.isEnabled) {
+      options.experimental.privacy = SentryPrivacyOptions()
+        ..maskAllText = false
+        ..maskAllImages = false;
+    } else {
+      options.experimental.privacy = SentryPrivacyOptions();
+    }
+  }
+
   /// Reports the time it took for the screen to be fully displayed.
   /// This requires the [SentryFlutterOptions.enableTimeToFullDisplayTracing] option to be set to `true`.
   static Future<void> reportFullyDisplayed() async {