redact screenshots via view hierarchy

.github/file-filters.yml

@@ -5,4 +5,5 @@ high_risk_code: &high_risk_code
   - "flutter/lib/src/integrations/native_app_start_integration.dart"
   - "flutter/android/src/main/kotlin/io/sentry/flutter/SentryFlutterPlugin.kt"
   - "flutter/ios/Classes/SentryFlutterPluginApple.swift"
-
+  - "flutter/lib/src/screenshot/recorder.dart"
+  - "flutter/lib/src/screenshot/widget_filter.dart"

CHANGELOG.md

@@ -13,6 +13,33 @@
 
 ### Features
 
+- Support for screenshot PII content redaction (masking) ([#2361](https://github.com/getsentry/sentry-dart/pull/2361))
+  By default, masking is enabled for SessionReplay. To also enable it for screenshots captured with events, you can specify `options.experimental.privacy`:
+  ```dart
+  await SentryFlutter.init(
+    (options) {
+      ...
+      // the defaults are:
+      options.experimental.privacy.maskAllText = true;
+      options.experimental.privacy.maskAllImages = true;
+      options.experimental.privacy.maskAssetImages = false;
+      // you cal also set up custom masking, for example:
+      options.experimental.privacy.mask<WebView>();
+    },
+    appRunner: () => runApp(MyApp()),
+  );
+  ```
+  Actually, just accessing this field will cause it to be initialized with the default settings to mask all text and images:
+  ```dart
+  await SentryFlutter.init(
+    (options) {
+      ...
+      // this has a side-effect of creating the default privacy configuration, thus enabling Screenshot redaction:
+      options.experimental.privacy;
+    },
+    appRunner: () => runApp(MyApp()),
+  );
+  ```  
 - Improve frame tracking accuracy ([#2372](https://github.com/getsentry/sentry-dart/pull/2372))
   - Introduces `SentryWidgetsFlutterBinding` that tracks a frame starting from `handleBeginFrame` and ending in `handleDrawFrame`, this is approximately the [buildDuration](https://api.flutter.dev/flutter/dart-ui/FrameTiming/buildDuration.html) time
   - By default, `SentryFlutter.init()` automatically initializes `SentryWidgetsFlutterBinding` through the `WidgetsFlutterBindingIntegration`

flutter/example/lib/main.dart

@@ -74,8 +74,7 @@ Future<void> setupSentry(
       options.addIntegration(LoggingIntegration(minEventLevel: Level.INFO));
       options.sendDefaultPii = true;
       options.reportSilentFlutterErrors = true;
-      options.attachScreenshot = true;
-      options.screenshotQuality = SentryScreenshotQuality.low;
+      options.screenshot.attach = true;
       options.attachViewHierarchy = true;
       // We can enable Sentry debug logging during development. This is likely
       // going to log too much for your app, but can be useful when figuring out
@@ -92,6 +91,10 @@ Future<void> setupSentry(
       options.experimental.replay.sessionSampleRate = 1.0;
       options.experimental.replay.onErrorSampleRate = 1.0;
 
+      // This has a side-effect of creating the default privacy configuration,
+      // thus enabling Screenshot redaction. No need to actually change it.
+      options.experimental.privacy;
+
       _isIntegrationTest = isIntegrationTest;
       if (_isIntegrationTest) {
         options.dist = '1';

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,20 +1,31 @@
 import 'dart:async';
-import 'dart:math';
 import 'dart:typed_data';
 import 'dart:ui';
 
-import 'package:flutter/rendering.dart';
 import 'package:meta/meta.dart';
-import 'package:sentry/sentry.dart';
-import '../screenshot/sentry_screenshot_widget.dart';
-import '../sentry_flutter_options.dart';
+import '../../sentry_flutter.dart';
 import '../renderer/renderer.dart';
+import '../screenshot/recorder.dart';
+import '../screenshot/recorder_config.dart';
 import 'package:flutter/widgets.dart' as widget;
 
 class ScreenshotEventProcessor implements EventProcessor {
   final SentryFlutterOptions _options;
 
-  ScreenshotEventProcessor(this._options);
+  late final ScreenshotRecorder _recorder;
+
+  ScreenshotEventProcessor(this._options) {
+    final targetResolution = _options.screenshot.quality.targetResolution();
+
+    _recorder = ScreenshotRecorder(
+      ScreenshotRecorderConfig(
+        width: targetResolution,
+        height: targetResolution,
+      ),
+      _options,
+      isReplayRecorder: false,
+    );
+  }
 
   @override
   Future<SentryEvent?> apply(SentryEvent event, Hint hint) async {
@@ -32,7 +43,7 @@
       return event; // No need to attach screenshot of feedback form.
     }
 
-    final beforeScreenshot = _options.beforeScreenshot;
+    final beforeScreenshot = _options.screenshot.beforeCapture;
     if (beforeScreenshot != null) {
       try {
         final result = beforeScreenshot(event, hint: hint);
@@ -69,92 +80,44 @@
       return event;
     }
 
-    if (_options.attachScreenshotOnlyWhenResumed &&
+    if (_options.screenshot.attachOnlyWhenResumed &&
         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);
+    Uint8List? screenshotData = await createScreenshot();
+
+    if (screenshotData != null) {
+      hint.screenshot = SentryAttachment.fromScreenshotData(screenshotData);
     }
+
     return event;
   }
 
   @internal
   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;
-      }
-    }
-    return null;
+    return screenshotData;
   }
 
-  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.attach] is true
 class ScreenshotIntegration implements Integration<SentryFlutterOptions> {
   SentryFlutterOptions? _options;
   ScreenshotEventProcessor? _screenshotEventProcessor;
 
   @override
   void call(Hub hub, SentryFlutterOptions options) {
-    if (options.attachScreenshot) {
+    if (options.screenshot.attach) {
       _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

@@ -4,8 +4,8 @@ import 'dart:ui';
 import 'package:meta/meta.dart';
 
 import '../../sentry_flutter.dart';
-import 'recorder.dart';
-import 'recorder_config.dart';
+import '../screenshot/recorder.dart';
+import 'scheduled_recorder_config.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;
+
+  ScheduledScreenshotRecorderConfig({
+    super.width,
+    super.height,
+    required this.frameRate,
+  });
+}