Merge 7fe87c6 into 2bfacef

Author: markushi

CLAUDE.md

@@ -0,0 +1,41 @@
+# sentry-java Development Guide for Claude
+
+## Overview
+
+sentry-java is the Java and Android SDK for Sentry. This repository contains the source code and examples for SDK usage.
+
+## Tech Stack
+
+- **Language**: Java and Kotlin
+- **Build Framework**: Gradle
+
+## Key Commands
+
+```bash
+# Format Code and regenerate .api file
+./gradlew spotlessApply apiDump
+
+# Run tests and lint
+./gradlew check
+```
+
+## Contributing Guidelines
+
+1. Before implementing a new feature, checkout main, pull the latest changes and branch-off
+```bash
+git checkout main
+git pull origin main
+git checkout -b markushi/[fix/feat]/[feature-name]
+```
+2. Follow existing code style and language
+3. Do not modify the API files (e.g. sentry.api) manually, instead run `./gradlew  apiDump` to regenerate them
+4. Write comprehensive tests
+5. Use Kotlin only for test code and Android modules which already use Kotlin, otherwise use Java
+6. New features should be opt-in by default, extend `SentryOptions` with getters and setters to enable/disable a new feature
+7. Consider backwards compatibility
+
+## Useful Resources
+
+- Main Documentation: https://docs.sentry.io/
+- Internal Contributing Guide: https://docs.sentry.io/internal/contributing/
+- Git Commit messages https://develop.sentry.dev/engineering-practices/commit-messages/

sentry-android-replay/src/main/java/io/sentry/android/replay/viewhierarchy/ViewHierarchyNode.kt

@@ -14,6 +14,7 @@ import io.sentry.android.replay.util.isMaskable
 import io.sentry.android.replay.util.isVisibleToUser
 import io.sentry.android.replay.util.toOpaque
 import io.sentry.android.replay.util.totalPaddingTopSafe
+import io.sentry.util.PatternUtils
 
 @TargetApi(26)
 internal sealed class ViewHierarchyNode(
@@ -311,6 +312,17 @@ internal sealed class ViewHierarchyNode(
         return false
       }
 
+      // Check package-based masking patterns
+      val className = this.javaClass.name
+      if (PatternUtils.matchesAnyPattern(className, options.sessionReplay.maskPackagePatterns)) {
+        return true
+      }
+      
+      // Check package-based unmasking patterns
+      if (PatternUtils.matchesAnyPattern(className, options.sessionReplay.unmaskPackagePatterns)) {
+        return false
+      }
+
       return this.javaClass.isAssignableFrom(options.sessionReplay.maskViewClasses)
     }
 

sentry-android-replay/src/test/java/io/sentry/android/replay/viewhierarchy/MaskingOptionsTest.kt

@@ -2,8 +2,10 @@ package io.sentry.android.replay.viewhierarchy
 
 import android.app.Activity
 import android.content.Context
+import android.graphics.Bitmap
 import android.graphics.Canvas
 import android.graphics.Color
+import android.graphics.drawable.BitmapDrawable
 import android.graphics.drawable.Drawable
 import android.os.Bundle
 import android.os.Looper
@@ -14,18 +16,22 @@ import android.widget.LinearLayout.LayoutParams
 import android.widget.RadioButton
 import android.widget.TextView
 import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.core.app.ApplicationProvider
 import io.sentry.SentryOptions
+import io.sentry.android.replay.R
 import io.sentry.android.replay.maskAllImages
 import io.sentry.android.replay.maskAllText
 import io.sentry.android.replay.sentryReplayMask
 import io.sentry.android.replay.sentryReplayUnmask
+import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.GenericViewHierarchyNode
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.ImageViewHierarchyNode
 import io.sentry.android.replay.viewhierarchy.ViewHierarchyNode.TextViewHierarchyNode
 import kotlin.test.BeforeTest
 import kotlin.test.Test
 import kotlin.test.assertFalse
 import kotlin.test.assertTrue
 import org.junit.runner.RunWith
+import org.robolectric.Robolectric
 import org.robolectric.Robolectric.buildActivity
 import org.robolectric.Shadows.shadowOf
 import org.robolectric.annotation.Config
@@ -225,6 +231,142 @@ class MaskingOptionsTest {
     assertTrue(textNode.shouldMask)
     assertTrue(imageNode.shouldMask)
   }
+
+  @Test
+  fun `views are masked when class name matches mask package pattern`() {
+    val textView = TextView(ApplicationProvider.getApplicationContext()).apply {
+      text = "Test text"
+      visibility = View.VISIBLE
+      measure(View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY),
+              View.MeasureSpec.makeMeasureSpec(50, View.MeasureSpec.EXACTLY))
+      layout(0, 0, 100, 50)
+    }
+    val imageView = ImageView(ApplicationProvider.getApplicationContext()).apply {
+      visibility = View.VISIBLE
+      measure(View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY),
+              View.MeasureSpec.makeMeasureSpec(50, View.MeasureSpec.EXACTLY))
+      layout(0, 0, 100, 50)
+    }
+    
+    // Create a bitmap drawable that should be considered maskable
+    val bitmap = Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888)
+    val context = ApplicationProvider.getApplicationContext<Context>()
+    val drawable = BitmapDrawable(context.resources, bitmap)
+    imageView.setImageDrawable(drawable)
+
+    val options =
+      SentryOptions().apply {
+        sessionReplay.addMaskPackage("android.widget.*")
+      }
+
+    val textNode = ViewHierarchyNode.fromView(textView, null, 0, options)
+    val imageNode = ViewHierarchyNode.fromView(imageView, null, 0, options)
+
+    // Both views from android.widget.* should be masked
+    assertTrue(textNode.shouldMask)
+    assertTrue(imageNode.shouldMask)
+  }
+
+  @Test
+  fun `views are unmasked when class name matches unmask package pattern`() {
+    val textView = TextView(ApplicationProvider.getApplicationContext())
+    val imageView = ImageView(ApplicationProvider.getApplicationContext())
+    
+    // Create a bitmap drawable that should be considered maskable
+    val bitmap = Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888)
+    val context = ApplicationProvider.getApplicationContext<Context>()
+    val drawable = BitmapDrawable(context.resources, bitmap)
+    imageView.setImageDrawable(drawable)
+
+    val options =
+      SentryOptions().apply {
+        sessionReplay.addMaskPackage("android.*")
+        sessionReplay.addUnmaskPackage("android.widget.*")
+      }
+
+    val textNode = ViewHierarchyNode.fromView(textView, null, 0, options)
+    val imageNode = ViewHierarchyNode.fromView(imageView, null, 0, options)
+
+    // Both views should be unmasked due to more specific unmask pattern
+    assertFalse(textNode.shouldMask)
+    assertFalse(imageNode.shouldMask)
+  }
+
+  @Test
+  fun `views are masked with specific package patterns`() {
+    val textView = TextView(ApplicationProvider.getApplicationContext()).apply {
+      text = "Test text"
+      visibility = View.VISIBLE
+      measure(View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY),
+              View.MeasureSpec.makeMeasureSpec(50, View.MeasureSpec.EXACTLY))
+      layout(0, 0, 100, 50)
+    }
+    val linearLayout = LinearLayout(ApplicationProvider.getApplicationContext()).apply {
+      visibility = View.VISIBLE
+      measure(View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY),
+              View.MeasureSpec.makeMeasureSpec(50, View.MeasureSpec.EXACTLY))
+      layout(0, 0, 100, 50)
+    }
+
+    val options =
+      SentryOptions().apply {
+        sessionReplay.addMaskPackage("android.widget.TextView")
+      }
+
+    val textNode = ViewHierarchyNode.fromView(textView, null, 0, options)
+    val layoutNode = ViewHierarchyNode.fromView(linearLayout, null, 0, options)
+
+    // TextView should be masked by exact match
+    assertTrue(textNode.shouldMask)
+    // LinearLayout should not be masked
+    assertFalse(layoutNode.shouldMask)
+  }
+
+  @Test
+  fun `package patterns work with multiple patterns`() {
+    val textView = TextView(ApplicationProvider.getApplicationContext()).apply {
+      text = "Test text"
+      visibility = View.VISIBLE
+      measure(View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY),
+              View.MeasureSpec.makeMeasureSpec(50, View.MeasureSpec.EXACTLY))
+      layout(0, 0, 100, 50)
+    }
+    val imageView = ImageView(ApplicationProvider.getApplicationContext()).apply {
+      visibility = View.VISIBLE
+      measure(View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY),
+              View.MeasureSpec.makeMeasureSpec(50, View.MeasureSpec.EXACTLY))
+      layout(0, 0, 100, 50)
+    }
+    val linearLayout = LinearLayout(ApplicationProvider.getApplicationContext()).apply {
+      visibility = View.VISIBLE
+      measure(View.MeasureSpec.makeMeasureSpec(100, View.MeasureSpec.EXACTLY),
+              View.MeasureSpec.makeMeasureSpec(50, View.MeasureSpec.EXACTLY))
+      layout(0, 0, 100, 50)
+    }
+    
+    // Create a bitmap drawable that should be considered maskable
+    val bitmap = Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888)
+    val context = ApplicationProvider.getApplicationContext<Context>()
+    val drawable = BitmapDrawable(context.resources, bitmap)
+    imageView.setImageDrawable(drawable)
+
+    val options =
+      SentryOptions().apply {
+        sessionReplay.addMaskPackage("android.widget.TextView")
+        sessionReplay.addMaskPackage("android.widget.ImageView")
+        sessionReplay.addUnmaskPackage("android.widget.LinearLayout")
+      }
+
+    val textNode = ViewHierarchyNode.fromView(textView, null, 0, options)
+    val imageNode = ViewHierarchyNode.fromView(imageView, null, 0, options)
+    val layoutNode = ViewHierarchyNode.fromView(linearLayout, null, 0, options)
+
+    // TextView and ImageView should be masked by exact matches
+    assertTrue(textNode.shouldMask)
+    assertTrue(imageNode.shouldMask)
+    // LinearLayout should not be masked (not in any mask patterns)
+    assertFalse(layoutNode.shouldMask)
+  }
 }
 
 private class CustomView(context: Context) : View(context) {

sentry/api/sentry.api

@@ -3665,10 +3665,13 @@ public final class io/sentry/SentryReplayOptions {
 	public static final field WEB_VIEW_CLASS_NAME Ljava/lang/String;
 	public fun <init> (Ljava/lang/Double;Ljava/lang/Double;Lio/sentry/protocol/SdkVersion;)V
 	public fun <init> (ZLio/sentry/protocol/SdkVersion;)V
+	public fun addMaskPackage (Ljava/lang/String;)V
 	public fun addMaskViewClass (Ljava/lang/String;)V
+	public fun addUnmaskPackage (Ljava/lang/String;)V
 	public fun addUnmaskViewClass (Ljava/lang/String;)V
 	public fun getErrorReplayDuration ()J
 	public fun getFrameRate ()I
+	public fun getMaskPackagePatterns ()Ljava/util/Set;
 	public fun getMaskViewClasses ()Ljava/util/Set;
 	public fun getMaskViewContainerClass ()Ljava/lang/String;
 	public fun getOnErrorSampleRate ()Ljava/lang/Double;
@@ -3677,6 +3680,7 @@ public final class io/sentry/SentryReplayOptions {
 	public fun getSessionDuration ()J
 	public fun getSessionSampleRate ()Ljava/lang/Double;
 	public fun getSessionSegmentDuration ()J
+	public fun getUnmaskPackagePatterns ()Ljava/util/Set;
 	public fun getUnmaskViewClasses ()Ljava/util/Set;
 	public fun getUnmaskViewContainerClass ()Ljava/lang/String;
 	public fun isDebug ()Z

sentry/src/main/java/io/sentry/SentryReplayOptions.java

@@ -91,6 +91,30 @@ public enum SentryReplayQuality {
    */
   private Set<String> unmaskViewClasses = new CopyOnWriteArraySet<>();
 
+  /**
+   * Mask all views with the specified package name patterns. The package name pattern can include
+   * wildcards (*) to match multiple packages. For example, "com.thirdparty.*" will mask all
+   * views from packages starting with "com.thirdparty.".
+   *
+   * <p>If you're using an obfuscation tool, make sure to add the respective proguard rules to keep
+   * the package names.
+   *
+   * <p>Default is empty.
+   */
+  private Set<String> maskPackagePatterns = new CopyOnWriteArraySet<>();
+
+  /**
+   * Ignore all views with the specified package name patterns from masking. The package name pattern can include
+   * wildcards (*) to match multiple packages. For example, "com.myapp.*" will unmask all
+   * views from packages starting with "com.myapp.".
+   *
+   * <p>If you're using an obfuscation tool, make sure to add the respective proguard rules to keep
+   * the package names.
+   *
+   * <p>Default is empty.
+   */
+  private Set<String> unmaskPackagePatterns = new CopyOnWriteArraySet<>();
+
   /** The class name of the view container that masks all of its children. */
   private @Nullable String maskViewContainerClass = null;
 
@@ -252,6 +276,24 @@ public void addUnmaskViewClass(final @NotNull String className) {
     this.unmaskViewClasses.add(className);
   }
 
+  @NotNull
+  public Set<String> getMaskPackagePatterns() {
+    return this.maskPackagePatterns;
+  }
+
+  public void addMaskPackage(final @NotNull String packagePattern) {
+    this.maskPackagePatterns.add(packagePattern);
+  }
+
+  @NotNull
+  public Set<String> getUnmaskPackagePatterns() {
+    return this.unmaskPackagePatterns;
+  }
+
+  public void addUnmaskPackage(final @NotNull String packagePattern) {
+    this.unmaskPackagePatterns.add(packagePattern);
+  }
+
   @ApiStatus.Internal
   public @NotNull SentryReplayQuality getQuality() {
     return quality;

sentry/src/main/java/io/sentry/rrweb/RRWebOptionsEvent.java

@@ -52,6 +52,8 @@ public RRWebOptionsEvent(final @NotNull SentryOptions options) {
     optionsPayload.put("quality", replayOptions.getQuality().serializedName());
     optionsPayload.put("maskedViewClasses", replayOptions.getMaskViewClasses());
     optionsPayload.put("unmaskedViewClasses", replayOptions.getUnmaskViewClasses());
+    optionsPayload.put("maskedPackagePatterns", replayOptions.getMaskPackagePatterns());
+    optionsPayload.put("unmaskedPackagePatterns", replayOptions.getUnmaskPackagePatterns());
   }
 
   @NotNull

sentry/src/main/java/io/sentry/util/PatternUtils.java

@@ -0,0 +1,59 @@
+package io.sentry.util;
+
+import java.util.Set;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Utility class for pattern matching operations, primarily used for Session Replay masking.
+ */
+public final class PatternUtils {
+
+  private PatternUtils() {}
+
+  /**
+   * Checks if a given string matches a pattern. The pattern can contain wildcards (*) only at the
+   * end to match any sequence of characters as a suffix.
+   *
+   * @param input the string to check
+   * @param pattern the pattern to match against (only suffix wildcards are supported)
+   * @return true if the input matches the pattern, false otherwise
+   */
+  public static boolean matchesPattern(final @NotNull String input, final @NotNull String pattern) {
+    // If pattern doesn't contain wildcard, do exact match
+    if (!pattern.contains("*")) {
+      return input.equals(pattern);
+    }
+    
+    // Only support suffix wildcards (pattern ending with *)
+    if (!pattern.endsWith("*")) {
+      return false;
+    }
+    
+    // Check if pattern has wildcards in the middle or beginning (not supported)
+    final String prefix = pattern.substring(0, pattern.length() - 1);
+    if (prefix.contains("*")) {
+      return false;
+    }
+    
+    // Check if input starts with the prefix
+    return input.startsWith(prefix);
+  }
+
+  /**
+   * Checks if a given string matches any of the provided patterns. Patterns can contain wildcards
+   * (*) only at the end to match any sequence of characters as a suffix.
+   *
+   * @param input the string to check
+   * @param patterns the set of patterns to match against
+   * @return true if the input matches any of the patterns, false otherwise
+   */
+  public static boolean matchesAnyPattern(
+      final @NotNull String input, final @NotNull Set<String> patterns) {
+    for (final String pattern : patterns) {
+      if (matchesPattern(input, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}