Merge branch 'refs/heads/main' into stefanosiano/fix/strict-mode-followup

Author: stefanosiano

.github/workflows/danger.yml

@@ -2,7 +2,7 @@ name: Danger
 
 on:
   pull_request:
-    types: [opened, synchronize, reopened, edited, ready_for_review]
+    types: [opened, synchronize, reopened, edited, ready_for_review, labeled, unlabeled]
 
 jobs:
   danger:

CHANGELOG.md

@@ -4,14 +4,40 @@
 
 ### Features
 
+- Attach MDC properties to logs as attributes ([#4786](https://github.com/getsentry/sentry-java/pull/4786))
+  - MDC properties set using supported logging frameworks (Logback, Log4j2, java.util.Logging) are now attached to structured logs as attributes.
+  - The attribute reflected on the log is `mdc.<key>`, where `<key>` is the original key in the MDC.
+  - This means that you will be able to filter/aggregate logs in the product based on these properties.
+  - Only properties with keys matching the configured `contextTags` are sent as log attributes.
+    - You can configure which properties are sent using `options.setContextTags` if initalizing manually, or by specifying a comma-separated list of keys with a `context-tags` entry in `sentry.properties` or `sentry.context-tags` in `application.properties`.
+    - Note that keys containing spaces are not supported.
 - Add experimental Sentry Android Distribution module for integrating with Sentry Build Distribution to check for and install updates ([#4804](https://github.com/getsentry/sentry-java/pull/4804))
+- Allow passing a different `Handler` to `SystemEventsBreadcrumbsIntegration` and `AndroidConnectionStatusProvider` so their callbacks are deliver to that handler ([#4808](https://github.com/getsentry/sentry-java/pull/4808))
+- Session Replay: Add new _experimental_ Canvas Capture Strategy ([#4777](https://github.com/getsentry/sentry-java/pull/4777))
+  - A new screenshot capture strategy that uses Android's Canvas API for more accurate and reliable text and image masking
+  - Any `.drawText()` or `.drawBitmap()` calls are replaced by rectangles, ensuring no text or images are present in the resulting output
+  - Note: If this strategy is used, all text and images will be masked, regardless of any masking configuration
+  - To enable this feature, set the `screenshotStrategy`, either via code:
+    ```kotlin
+    SentryAndroid.init(context) { options ->
+      options.sessionReplay.screenshotStrategy = ScreenshotStrategyType.CANVAS
+    }
+    ```
+    or AndroidManifest.xml:
+    ```xml
+    <application>
+      <meta-data android:name="io.sentry.session-replay.screenshot-strategy" android:value="canvas" />
+    </application>
+    ```
 
 ### Fixes
 
 - Avoid StrictMode warnings (followup) ([#4809](https://github.com/getsentry/sentry-java/pull/4809))
 - Avoid StrictMode warnings ([#4724](https://github.com/getsentry/sentry-java/pull/4724))
 - Use logger from options for JVM profiler ([#4771](https://github.com/getsentry/sentry-java/pull/4771))
 - Session Replay: Avoid deadlock when pausing replay if no connection ([#4788](https://github.com/getsentry/sentry-java/pull/4788))
+- Session Replay: Fix capturing roots with no windows ([#4805](https://github.com/getsentry/sentry-java/pull/4805))
+- Session Replay: Fix `java.lang.IllegalArgumentException: width and height must be > 0` ([#4805](https://github.com/getsentry/sentry-java/pull/4805))
 
 ### Miscellaneous
 

gradle/libs.versions.toml

@@ -91,6 +91,7 @@ androidx-navigation-runtime = { module = "androidx.navigation:navigation-runtime
 androidx-navigation-compose = { module = "androidx.navigation:navigation-compose", version.ref = "androidxNavigation" }
 androidx-sqlite = { module = "androidx.sqlite:sqlite", version = "2.5.2" }
 androidx-recyclerview = { module = "androidx.recyclerview:recyclerview", version = "1.2.1" }
+androidx-browser = { module = "androidx.browser:browser", version = "1.8.0" }
 coil-compose = { module = "io.coil-kt:coil-compose", version = "2.6.0" }
 commons-compress = {module = "org.apache.commons:commons-compress", version = "1.25.0"}
 context-propagation = { module = "io.micrometer:context-propagation", version = "1.1.0" }

sentry-android-core/api/sentry-android-core.api

@@ -446,6 +446,7 @@ public class io/sentry/android/core/SpanFrameMetricsCollector : io/sentry/IPerfo
 
 public final class io/sentry/android/core/SystemEventsBreadcrumbsIntegration : io/sentry/Integration, io/sentry/android/core/AppState$AppStateListener, java/io/Closeable {
 	public fun <init> (Landroid/content/Context;)V
+	public fun <init> (Landroid/content/Context;Landroid/os/Handler;)V
 	public fun <init> (Landroid/content/Context;Ljava/util/List;)V
 	public fun close ()V
 	public static fun getDefaultActions ()Ljava/util/List;

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

@@ -6,6 +6,7 @@
 import io.sentry.ILogger;
 import io.sentry.InitPriority;
 import io.sentry.ProfileLifecycle;
+import io.sentry.ScreenshotStrategyType;
 import io.sentry.SentryFeedbackOptions;
 import io.sentry.SentryIntegrationPackageStorage;
 import io.sentry.SentryLevel;
@@ -111,6 +112,7 @@ final class ManifestMetadataReader {
   static final String REPLAYS_MASK_ALL_IMAGES = "io.sentry.session-replay.mask-all-images";
 
   static final String REPLAYS_DEBUG = "io.sentry.session-replay.debug";
+  static final String REPLAYS_SCREENSHOT_STRATEGY = "io.sentry.session-replay.screenshot-strategy";
 
   static final String FORCE_INIT = "io.sentry.force-init";
 
@@ -476,6 +478,16 @@ static void applyMetadata(
 
         options.getSessionReplay().setDebug(readBool(metadata, logger, REPLAYS_DEBUG, false));
 
+        final @Nullable String screenshotStrategyRaw =
+            readString(metadata, logger, REPLAYS_SCREENSHOT_STRATEGY, null);
+        if (screenshotStrategyRaw != null) {
+          if ("canvas".equals(screenshotStrategyRaw.toLowerCase(Locale.ROOT))) {
+            options.getSessionReplay().setScreenshotStrategy(ScreenshotStrategyType.CANVAS);
+          } else {
+            // always default to PIXEL_COPY
+            options.getSessionReplay().setScreenshotStrategy(ScreenshotStrategyType.PIXEL_COPY);
+          }
+        }
         options.setIgnoredErrors(readList(metadata, logger, IGNORED_ERRORS));
 
         final @Nullable List<String> includes = readList(metadata, logger, IN_APP_INCLUDES);

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

@@ -232,6 +232,7 @@ private static void deduplicateIntegrations(
 
     final List<Integration> timberIntegrations = new ArrayList<>();
     final List<Integration> fragmentIntegrations = new ArrayList<>();
+    final List<Integration> systemEventsIntegrations = new ArrayList<>();
 
     for (final Integration integration : options.getIntegrations()) {
       if (isFragmentAvailable) {
@@ -244,6 +245,9 @@ private static void deduplicateIntegrations(
           timberIntegrations.add(integration);
         }
       }
+      if (integration instanceof SystemEventsBreadcrumbsIntegration) {
+        systemEventsIntegrations.add(integration);
+      }
     }
 
     if (fragmentIntegrations.size() > 1) {
@@ -259,5 +263,12 @@ private static void deduplicateIntegrations(
         options.getIntegrations().remove(integration);
       }
     }
+
+    if (systemEventsIntegrations.size() > 1) {
+      for (int i = 0; i < systemEventsIntegrations.size() - 1; i++) {
+        final Integration integration = systemEventsIntegrations.get(i);
+        options.getIntegrations().remove(integration);
+      }
+    }
   }
 }

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

@@ -72,15 +72,24 @@ public final class SystemEventsBreadcrumbsIntegration
   private final @NotNull AutoClosableReentrantLock receiverLock = new AutoClosableReentrantLock();
   // Track previous battery state to avoid duplicate breadcrumbs when values haven't changed
   private @Nullable BatteryState previousBatteryState;
+  @TestOnly @Nullable Handler customHandler = null;
 
   public SystemEventsBreadcrumbsIntegration(final @NotNull Context context) {
-    this(context, getDefaultActionsInternal());
+    this(context, getDefaultActionsInternal(), null);
+  }
+
+  public SystemEventsBreadcrumbsIntegration(
+      final @NotNull Context context, final @NotNull Handler handler) {
+    this(context, getDefaultActionsInternal(), handler);
   }
 
   SystemEventsBreadcrumbsIntegration(
-      final @NotNull Context context, final @NotNull String[] actions) {
+      final @NotNull Context context,
+      final @NotNull String[] actions,
+      final @Nullable Handler handler) {
     this.context = ContextUtils.getApplicationContext(context);
     this.actions = actions;
+    this.customHandler = handler;
   }
 
   public SystemEventsBreadcrumbsIntegration(
@@ -143,7 +152,7 @@ private void registerReceiver(
                       filter.addAction(item);
                     }
                   }
-                  if (handlerThread == null) {
+                  if (customHandler == null && handlerThread == null) {
                     handlerThread =
                         new HandlerThread(
                             "SystemEventsReceiver", Process.THREAD_PRIORITY_BACKGROUND);
@@ -154,7 +163,12 @@ private void registerReceiver(
                     // official docs
 
                     // onReceive will be called on this handler thread
-                    final @NotNull Handler handler = new Handler(handlerThread.getLooper());
+                    @NotNull Handler handler;
+                    if (customHandler != null) {
+                      handler = customHandler;
+                    } else {
+                      handler = new Handler(handlerThread.getLooper());
+                    }
                     ContextUtils.registerReceiver(context, options, receiver, filter, handler);
                     if (!isReceiverRegistered.getAndSet(true)) {
                       options

sentry-android-core/src/main/java/io/sentry/android/core/internal/util/AndroidConnectionStatusProvider.java

@@ -8,6 +8,7 @@
 import android.net.Network;
 import android.net.NetworkCapabilities;
 import android.os.Build;
+import android.os.Handler;
 import androidx.annotation.NonNull;
 import androidx.annotation.RequiresApi;
 import io.sentry.IConnectionStatusProvider;
@@ -42,6 +43,7 @@ public final class AndroidConnectionStatusProvider
   private final @NotNull BuildInfoProvider buildInfoProvider;
   private final @NotNull ICurrentDateProvider timeProvider;
   private final @NotNull List<IConnectionStatusObserver> connectionStatusObservers;
+  private final @Nullable Handler handler;
   private final @NotNull AutoClosableReentrantLock lock = new AutoClosableReentrantLock();
   private volatile @Nullable NetworkCallback networkCallback;
 
@@ -68,16 +70,26 @@ public final class AndroidConnectionStatusProvider
   private static final long CACHE_TTL_MS = 2 * 60 * 1000L; // 2 minutes
   private final @NotNull AtomicBoolean isConnected = new AtomicBoolean(false);
 
-  @SuppressLint("InlinedApi")
   public AndroidConnectionStatusProvider(
       @NotNull Context context,
       @NotNull SentryOptions options,
       @NotNull BuildInfoProvider buildInfoProvider,
       @NotNull ICurrentDateProvider timeProvider) {
+    this(context, options, buildInfoProvider, timeProvider, null);
+  }
+
+  @SuppressLint("InlinedApi")
+  public AndroidConnectionStatusProvider(
+      @NotNull Context context,
+      @NotNull SentryOptions options,
+      @NotNull BuildInfoProvider buildInfoProvider,
+      @NotNull ICurrentDateProvider timeProvider,
+      @Nullable Handler handler) {
     this.context = ContextUtils.getApplicationContext(context);
     this.options = options;
     this.buildInfoProvider = buildInfoProvider;
     this.timeProvider = timeProvider;
+    this.handler = handler;
     this.connectionStatusObservers = new ArrayList<>();
 
     capabilities[0] = NetworkCapabilities.NET_CAPABILITY_INTERNET;
@@ -326,7 +338,8 @@ private boolean hasSignificantTransportChanges(
             }
           };
 
-      if (registerNetworkCallback(context, options.getLogger(), buildInfoProvider, callback)) {
+      if (registerNetworkCallback(
+          context, options.getLogger(), buildInfoProvider, handler, callback)) {
         networkCallback = callback;
         options.getLogger().log(SentryLevel.DEBUG, "Network callback registered successfully");
       } else {
@@ -744,6 +757,7 @@ static boolean registerNetworkCallback(
       final @NotNull Context context,
       final @NotNull ILogger logger,
       final @NotNull BuildInfoProvider buildInfoProvider,
+      final @Nullable Handler handler,
       final @NotNull NetworkCallback networkCallback) {
     if (buildInfoProvider.getSdkInfoVersion() < Build.VERSION_CODES.N) {
       logger.log(SentryLevel.DEBUG, "NetworkCallbacks need Android N+.");
@@ -758,7 +772,11 @@ static boolean registerNetworkCallback(
       return false;
     }
     try {
-      connectivityManager.registerDefaultNetworkCallback(networkCallback);
+      if (handler != null) {
+        connectivityManager.registerDefaultNetworkCallback(networkCallback, handler);
+      } else {
+        connectivityManager.registerDefaultNetworkCallback(networkCallback);
+      }
     } catch (Throwable t) {
       logger.log(SentryLevel.WARNING, "registerDefaultNetworkCallback failed", t);
       return false;

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

@@ -1835,4 +1835,51 @@ class ManifestMetadataReaderTest {
     // Assert
     assertFalse(fixture.options.feedbackOptions.isShowBranding)
   }
+
+  @Test
+  fun `applyMetadata reads screenshot strategy canvas to options`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.REPLAYS_SCREENSHOT_STRATEGY to "canvas")
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(
+      io.sentry.ScreenshotStrategyType.CANVAS,
+      fixture.options.sessionReplay.screenshotStrategy,
+    )
+  }
+
+  @Test
+  fun `applyMetadata reads screenshot strategy and defaults to PIXEL_COPY for unknown value`() {
+    // Arrange
+    val bundle = bundleOf(ManifestMetadataReader.REPLAYS_SCREENSHOT_STRATEGY to "unknown")
+    val context = fixture.getContext(metaData = bundle)
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(
+      io.sentry.ScreenshotStrategyType.PIXEL_COPY,
+      fixture.options.sessionReplay.screenshotStrategy,
+    )
+  }
+
+  @Test
+  fun `applyMetadata reads screenshot strategy and keeps default if not found`() {
+    // Arrange
+    val context = fixture.getContext()
+
+    // Act
+    ManifestMetadataReader.applyMetadata(context, fixture.options, fixture.buildInfoProvider)
+
+    // Assert
+    assertEquals(
+      io.sentry.ScreenshotStrategyType.PIXEL_COPY,
+      fixture.options.sessionReplay.screenshotStrategy,
+    )
+  }
 }

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

@@ -6,6 +6,7 @@ import android.app.ApplicationExitInfo
 import android.content.Context
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
 import android.os.Looper
 import android.os.SystemClock
 import androidx.test.core.app.ApplicationProvider
@@ -237,13 +238,19 @@ class SentryAndroidTest {
   }
 
   @Test
-  fun `deduplicates fragment and timber integrations`() {
+  fun `deduplicates fragment, timber and system events integrations`() {
     var refOptions: SentryAndroidOptions? = null
-
     fixture.initSut(autoInit = true) {
       it.addIntegration(FragmentLifecycleIntegration(ApplicationProvider.getApplicationContext()))
 
       it.addIntegration(SentryTimberIntegration(minEventLevel = FATAL, minBreadcrumbLevel = DEBUG))
+
+      it.addIntegration(
+        SystemEventsBreadcrumbsIntegration(
+          ApplicationProvider.getApplicationContext(),
+          CustomHandler(Looper.getMainLooper()),
+        )
+      )
       refOptions = it
     }
 
@@ -256,6 +263,11 @@ class SentryAndroidTest {
     // fragment integration is not auto-installed in the test, since the context is not Application
     // but we just verify here that the single integration is preserved
     assertEquals(refOptions!!.integrations.filterIsInstance<FragmentLifecycleIntegration>().size, 1)
+
+    val systemEventsIntegrations =
+      refOptions!!.integrations.filterIsInstance<SystemEventsBreadcrumbsIntegration>()
+    assertEquals(systemEventsIntegrations.size, 1)
+    assertTrue(systemEventsIntegrations.first().customHandler is CustomHandler)
   }
 
   @Test
@@ -580,3 +592,5 @@ fun initForTest(context: Context, logger: ILogger) {
 fun initForTest(context: Context) {
   SentryAndroid.init(context)
 }
+
+class CustomHandler(looper: Looper) : Handler(looper)