Merge branch 'main' into replay-link-events

jamescrosswell · jamescrosswell · commit 05c674cdab96 · 2025-04-28T13:52:31.000+12:00
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
@@ -112,9 +112,11 @@ jobs:
         run: dotnet restore Sentry-CI-Build-${{ runner.os }}.slnf --nologo
 
       - name: Build
+        id: build
         run: dotnet build Sentry-CI-Build-${{ runner.os }}.slnf -c Release --no-restore --nologo -v:minimal -flp:logfile=build.log -p:CopyLocalLockFileAssemblies=true -bl:build.binlog
 
       - name: Upload build logs
+        if: ${{ steps.build.outcome != 'skipped' }}
         uses: actions/upload-artifact@v4
         with:
           name: ${{ runner.os }}-build-logs
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,7 +4,18 @@
 
 ### Features
 
-- Option to disable the SentryNative integration ([#4107](https://github.com/getsentry/sentry-dotnet/pull/4107))
+- Custom SessionReplay masks in MAUI Android apps ([#4121](https://github.com/getsentry/sentry-dotnet/pull/4121))
+
+### Fixes
+
+- Work around iOS SHA1 bug ([#4143](https://github.com/getsentry/sentry-dotnet/pull/4143))
+
+## 5.6.0
+
+### Features
+
+- Option to disable the SentryNative integration ([#4107](https://github.com/getsentry/sentry-dotnet/pull/4107), [#4134](https://github.com/getsentry/sentry-dotnet/pull/4134))
+  - To disable it, add this msbuild property: `<SentryNative>false</SentryNative>` 
 - Reintroduced experimental support for Session Replay on Android ([#4097](https://github.com/getsentry/sentry-dotnet/pull/4097))
 - Associate replays with errors and traces on Android ([#4133](https://github.com/getsentry/sentry-dotnet/pull/4133))
 
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -1,7 +1,7 @@
 <Project>
 
   <PropertyGroup>
-    <VersionPrefix>5.5.1</VersionPrefix>
+    <VersionPrefix>5.6.0</VersionPrefix>
     <LangVersion>13</LangVersion>
     <AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
     <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
diff --git a/samples/Sentry.Samples.Maui/MainPage.xaml b/samples/Sentry.Samples.Maui/MainPage.xaml
@@ -1,6 +1,7 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
              xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+             xmlns:sentry="http://schemas.sentry.io/maui"
              x:Class="Sentry.Samples.Maui.MainPage">
 
     <ScrollView>
@@ -11,6 +12,7 @@
 
             <Image
                 Source="dotnet_bot.png"
+                sentry:SessionReplay.Mask="Unmask"
                 SemanticProperties.Description="Cute dot net bot waving hi to you!"
                 HeightRequest="200"
                 HorizontalOptions="Center" />
diff --git a/samples/Sentry.Samples.Maui/MauiProgram.cs b/samples/Sentry.Samples.Maui/MauiProgram.cs
@@ -25,12 +25,17 @@ public static MauiApp CreateMauiApp()
                 options.Debug = true;
                 options.SampleRate = 1.0F;
 
-#if ANDROID
+#if __ANDROID__
                 // Currently experimental support is only available on Android
                 options.Native.ExperimentalOptions.SessionReplay.OnErrorSampleRate = 1.0;
                 options.Native.ExperimentalOptions.SessionReplay.SessionSampleRate = 1.0;
-                options.Native.ExperimentalOptions.SessionReplay.MaskAllImages = false;
-                options.Native.ExperimentalOptions.SessionReplay.MaskAllText = false;
+                // Mask all images and text by default. This can be overridden for individual view elements via the
+                // sentry:SessionReplay.Mask XML attribute (see MainPage.xaml for an example)
+                options.Native.ExperimentalOptions.SessionReplay.MaskAllImages = true;
+                options.Native.ExperimentalOptions.SessionReplay.MaskAllText = true;
+                // Alternatively the masking behaviour for entire classes of VisualElements can be configured here as
+                // an exception to the default behaviour.
+                options.Native.ExperimentalOptions.SessionReplay.UnmaskControlsOfType<Button>();
 #endif
 
                 options.SetBeforeScreenshotCapture((@event, hint) =>
diff --git a/samples/Sentry.Samples.Maui/Platforms/Android/MainActivity.cs b/samples/Sentry.Samples.Maui/Platforms/Android/MainActivity.cs
@@ -1,5 +1,8 @@
+#if __ANDROID__
 using Android.App;
 using Android.Content.PM;
+using Android.OS;
+#endif
 
 namespace Sentry.Samples.Maui;
 
diff --git a/src/Sentry.Maui/AssemblyInfo.cs b/src/Sentry.Maui/AssemblyInfo.cs
@@ -0,0 +1,3 @@
+// XML namespaces for custom XAML elements defined in the Sentry.Maui assembly (e.g. Bindable Properties)
+[assembly: XmlnsDefinition("http://schemas.sentry.io/maui", "Sentry.Maui")]
+[assembly: Microsoft.Maui.Controls.XmlnsPrefix("http://schemas.sentry.io/maui", "sentry")]
diff --git a/src/Sentry.Maui/Internal/MauiButtonEventsBinder.cs b/src/Sentry.Maui/Internal/MauiButtonEventsBinder.cs
@@ -29,7 +29,6 @@ public void UnBind(VisualElement element)
         }
     }
 
-
     private void OnButtonOnClicked(object? sender, EventArgs _)
         => addBreadcrumbCallback?.Invoke(new(sender, nameof(Button.Clicked)));
 
diff --git a/src/Sentry.Maui/Internal/MauiEventsBinder.cs b/src/Sentry.Maui/Internal/MauiEventsBinder.cs
@@ -1,4 +1,6 @@
 using Microsoft.Extensions.Options;
+using Microsoft.Maui.Platform;
+using Sentry.Extensibility;
 
 namespace Sentry.Maui.Internal;
 
diff --git a/src/Sentry.Maui/Internal/MauiVisualElementEventsBinder.cs b/src/Sentry.Maui/Internal/MauiVisualElementEventsBinder.cs
@@ -0,0 +1,66 @@
+using Microsoft.Extensions.Options;
+using Sentry.Extensibility;
+#if __ANDROID__
+using View = Android.Views.View;
+#endif
+
+namespace Sentry.Maui.Internal;
+
+/// <summary>
+/// Masks or unmasks visual elements for session replay recordings
+/// </summary>
+internal class MauiVisualElementEventsBinder : IMauiElementEventBinder
+{
+    private readonly SentryMauiOptions _options;
+
+    public MauiVisualElementEventsBinder(IOptions<SentryMauiOptions> options)
+    {
+        _options = options.Value;
+    }
+
+    /// <inheritdoc />
+    public void Bind(VisualElement element, Action<BreadcrumbEvent> _)
+    {
+        element.Loaded += OnElementLoaded;
+    }
+
+    /// <inheritdoc />
+    public void UnBind(VisualElement element)
+    {
+        element.Loaded -= OnElementLoaded;
+    }
+
+    internal void OnElementLoaded(object? sender, EventArgs _)
+    {
+        if (sender is not VisualElement element)
+        {
+            _options.LogDebug("OnElementLoaded: sender is not a VisualElement");
+            return;
+        }
+
+        var handler = element.Handler;
+        if (handler is null)
+        {
+            _options.LogDebug("OnElementLoaded: element.Handler is null");
+            return;
+        }
+
+#if __ANDROID__
+        if (element.Handler?.PlatformView is not View nativeView)
+        {
+            return;
+        }
+
+        if (_options.Native.ExperimentalOptions.SessionReplay.MaskedControls.FirstOrDefault(maskType => element.GetType().IsAssignableFrom(maskType)) is not null)
+        {
+            nativeView.Tag = SessionReplayMaskMode.Mask.ToNativeTag();
+            _options.LogDebug("OnElementLoaded: Successfully set sentry-mask tag on native view");
+        }
+        else if (_options.Native.ExperimentalOptions.SessionReplay.UnmaskedControls.FirstOrDefault(unmaskType => element.GetType().IsAssignableFrom(unmaskType)) is not null)
+        {
+            nativeView.Tag = SessionReplayMaskMode.Unmask.ToNativeTag();
+            _options.LogDebug("OnElementLoaded: Successfully set sentry-unmask tag on native view");
+        }
+#endif
+    }
+}
diff --git a/src/Sentry.Maui/SentryMauiAppBuilderExtensions.cs b/src/Sentry.Maui/SentryMauiAppBuilderExtensions.cs
@@ -57,6 +57,7 @@ public static MauiAppBuilder UseSentry(this MauiAppBuilder builder,
 
         services.AddSingleton<IMauiElementEventBinder, MauiButtonEventsBinder>();
         services.AddSingleton<IMauiElementEventBinder, MauiImageButtonEventsBinder>();
+        services.AddSingleton<IMauiElementEventBinder, MauiVisualElementEventsBinder>();
         services.TryAddSingleton<IMauiEventsBinder, MauiEventsBinder>();
 
         services.AddSentry<SentryMauiOptions>();
diff --git a/src/Sentry.Maui/SentryMauiOptions.cs b/src/Sentry.Maui/SentryMauiOptions.cs
@@ -81,7 +81,7 @@ public SentryMauiOptions()
     /// if this callback return false the capture will not take place
     /// </remarks>
     /// <code>
-    /// 
+    ///
     ///options.SetBeforeCapture((@event, hint) =>
     ///{
     ///    // Return true to capture or false to prevent the capture
diff --git a/src/Sentry.Maui/SessionReplay.cs b/src/Sentry.Maui/SessionReplay.cs
@@ -0,0 +1,90 @@
+
+using Sentry.Infrastructure;
+#if __ANDROID__
+using View = Android.Views.View;
+using Android.Views;
+using Java.Lang;
+using Microsoft.Maui.Handlers;
+using Microsoft.Maui.Platform;
+#endif
+
+namespace Sentry.Maui;
+
+/// <summary>
+/// Contains custom <see cref="BindableProperty"/> definitions used to control the behaviour of the Sentry SessionReplay
+/// feature in MAUI apps.
+/// <remarks>
+/// NOTE: Session Replay is currently an experimental feature for MAUI and is subject to change.
+/// </remarks>
+/// </summary>
+public static class SessionReplay
+{
+    /// <summary>
+    /// Mask can be used to either unmask or mask a view.
+    /// </summary>
+    public static readonly BindableProperty MaskProperty =
+        BindableProperty.CreateAttached(
+            "Mask",
+            typeof(SessionReplayMaskMode),
+            typeof(SessionReplay),
+            defaultValue: SessionReplayMaskMode.Mask,
+            propertyChanged: OnMaskChanged);
+
+    /// <summary>
+    /// Gets the value of the Mask property for a view.
+    /// </summary>
+    public static SessionReplayMaskMode GetMask(BindableObject view) => (SessionReplayMaskMode)view.GetValue(MaskProperty);
+
+    /// <summary>
+    /// Sets the value of the Mask property for a view.
+    /// </summary>
+    /// <param name="view">The view element to mask or unmask</param>
+    /// <param name="value">The value to assign. Can be either "sentry-mask" or "sentry-unmask".</param>
+    public static void SetMask(BindableObject view, SessionReplayMaskMode value) => view.SetValue(MaskProperty, value);
+
+    private static void OnMaskChanged(BindableObject bindable, object oldValue, object newValue)
+    {
+#if __ANDROID__
+        if (bindable is not VisualElement ve || newValue is not SessionReplayMaskMode maskSetting)
+        {
+            return;
+        }
+
+        // This code looks pretty funky... just matching how funky MAUI is though.
+        // See https://github.com/getsentry/sentry-dotnet/pull/4121#discussion_r2054129378
+        ve.HandlerChanged -= OnMaskedElementHandlerChanged;
+        ve.HandlerChanged -= OnUnmaskedElementHandlerChanged;
+
+        if (maskSetting == SessionReplayMaskMode.Mask)
+        {
+            ve.HandlerChanged += OnMaskedElementHandlerChanged;
+        }
+        else if (maskSetting == SessionReplayMaskMode.Unmask)
+        {
+            ve.HandlerChanged += OnUnmaskedElementHandlerChanged;
+        }
+#endif
+    }
+
+#if __ANDROID__
+    private static void OnMaskedElementHandlerChanged(object? sender, EventArgs _)
+    {
+        if ((sender as VisualElement)?.Handler?.PlatformView is not View nativeView)
+        {
+            return;
+        }
+
+        nativeView.Tag = SessionReplayMaskMode.Mask.ToNativeTag();
+    }
+
+    private static void OnUnmaskedElementHandlerChanged(object? sender, EventArgs _)
+    {
+        if ((sender as VisualElement)?.Handler?.PlatformView is not View nativeView)
+        {
+            return;
+        }
+
+        nativeView.Tag = SessionReplayMaskMode.Unmask.ToNativeTag();
+    }
+#endif
+}
diff --git a/src/Sentry.Maui/SessionReplayMaskMode.cs b/src/Sentry.Maui/SessionReplayMaskMode.cs
@@ -0,0 +1,32 @@
+namespace Sentry.Maui;
+
+/// <summary>
+/// Controls the masking behaviour of the Session Replay feature.
+/// </summary>
+public enum SessionReplayMaskMode
+{
+    /// <summary>
+    /// Masks the view
+    /// </summary>
+    Mask,
+    /// <summary>
+    /// Unmasks the view
+    /// </summary>
+    Unmask
+}
+
+internal static class SessionReplayMaskModeExtensions
+{
+#if __ANDROID__
+    /// <summary>
+    /// Maps from <see cref="SessionReplayMaskMode"/> to the native tag values used by the JavaSDK to mask and unmask
+    /// views. See https://docs.sentry.io/platforms/android/session-replay/privacy/#mask-by-view-instance
+    /// </summary>
+    public static string ToNativeTag(this SessionReplayMaskMode maskMode) => maskMode switch
+    {
+        SessionReplayMaskMode.Mask => "sentry-mask",
+        SessionReplayMaskMode.Unmask => "sentry-unmask",
+        _ => throw new ArgumentOutOfRangeException(nameof(maskMode), maskMode, null)
+    };
+#endif
+}
diff --git a/src/Sentry/Platforms/Android/NativeOptions.cs b/src/Sentry/Platforms/Android/NativeOptions.cs
@@ -272,6 +272,18 @@ public class NativeSentryReplayOptions
             public double? SessionSampleRate { get; set; }
             public bool MaskAllImages { get; set; } = true;
             public bool MaskAllText { get; set; } = true;
+            internal HashSet<Type> MaskedControls { get; } = [];
+            internal HashSet<Type> UnmaskedControls { get; } = [];
+
+            public void MaskControlsOfType<T>()
+            {
+                MaskedControls.Add(typeof(T));
+            }
+
+            public void UnmaskControlsOfType<T>()
+            {
+                UnmaskedControls.Add(typeof(T));
+            }
         }
 
         /// <summary>
diff --git a/src/Sentry/Platforms/Native/buildTransitive/Sentry.Native.targets b/src/Sentry/Platforms/Native/buildTransitive/Sentry.Native.targets
@@ -9,11 +9,11 @@
 <Project>
 
   <ItemGroup>
-    <!-- When user sets <DisableSentryNative>true</DisableSentryNative> in their project -->
+    <!-- When user sets <SentryNative>false</SentryNative> or <SentryNative>disable</SentryNative> in their project -->
     <!-- SentryNative.IsEnabled should result in compile-time constant for trimmed applications -->
     <!-- Effectively disabling native library -->
     <RuntimeHostConfigurationOption Include="Sentry.Native.IsEnabled"
-                                    Condition="'$(DisableSentryNative)' != 'true'"
+                                    Condition="'$(SentryNative)' != 'false' and '$(SentryNative)' != 'disable'"
                                     Value="true"
                                     Trim="true" />
   </ItemGroup>
@@ -22,7 +22,7 @@
     <!-- net8.0 or greater -->
     <FrameworkSupportsNative Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net8.0')) and ('$(OutputType)' == 'Exe' or '$(OutputType)' == 'WinExe')">true</FrameworkSupportsNative>
     <!-- Make it opt-out -->
-    <FrameworkSupportsNative Condition="'$(DisableSentryNative)' == 'true'">false</FrameworkSupportsNative>
+    <FrameworkSupportsNative Condition="'$(SentryNative)' == 'false' or '$(SentryNative)' == 'disable'">false</FrameworkSupportsNative>
   </PropertyGroup>
 
   <ItemGroup Condition="'$(FrameworkSupportsNative)' == 'true' and '$(RuntimeIdentifier)' == 'win-x64'">
diff --git a/src/Sentry/Sentry.csproj b/src/Sentry/Sentry.csproj
@@ -22,6 +22,7 @@
 
   <ItemGroup Condition="'$(SolutionName)' == 'Sentry.Unity'">
     <InternalsVisibleTo Include="Sentry.Unity" />
+    <InternalsVisibleTo Include="Sentry.Unity.Tests" />
   </ItemGroup>
 
   <!-- Platform-specific props included here -->
diff --git a/src/Sentry/SentryOptions.cs b/src/Sentry/SentryOptions.cs
@@ -1816,8 +1816,11 @@ internal void SetupLogging()
         {
             return null;
         }
-
+#if IOS || ANDROID // on iOS or Android the app is already sandboxed so there's no risk of sending data from 1 app to another Sentry's DSN
+        return Path.Combine(CacheDirectoryPath, "Sentry");
+#else
         return Path.Combine(CacheDirectoryPath, "Sentry", Dsn.GetHashString());
+#endif
     }
 
     internal string? TryGetProcessSpecificCacheDirectoryPath()
diff --git a/src/Sentry/SentrySdk.cs b/src/Sentry/SentrySdk.cs
@@ -209,13 +209,6 @@ internal static IDisposable UseHub(IHub hub)
         return new DisposeHandle(hub);
     }
 
-    /// <summary>
-    /// Allows to set the trace
-    /// </summary>
-    internal static void SetTrace(SentryId traceId, SpanId parentSpanId) =>
-        CurrentHub.ConfigureScope(scope =>
-            scope.SetPropagationContext(new SentryPropagationContext(traceId, parentSpanId)));
-
     /// <summary>
     /// Flushes the queue of captured events until the timeout set in <see cref="SentryOptions.FlushTimeout"/>
     /// is reached.
diff --git a/test/Sentry.Maui.Tests/ApiApprovalTests.Run.DotNet8_0.verified.txt b/test/Sentry.Maui.Tests/ApiApprovalTests.Run.DotNet8_0.verified.txt
diff --git a/test/Sentry.Maui.Tests/ApiApprovalTests.Run.DotNet9_0.verified.txt b/test/Sentry.Maui.Tests/ApiApprovalTests.Run.DotNet9_0.verified.txt
diff --git a/test/Sentry.Maui.Tests/MauiEventsBinderTests.VisualElement.cs b/test/Sentry.Maui.Tests/MauiEventsBinderTests.VisualElement.cs
diff --git a/test/Sentry.Maui.Tests/MauiEventsBinderTests.cs b/test/Sentry.Maui.Tests/MauiEventsBinderTests.cs
diff --git a/test/Sentry.Maui.Tests/MauiVisualElementEventsBinderTests.cs b/test/Sentry.Maui.Tests/MauiVisualElementEventsBinderTests.cs
diff --git a/test/Sentry.Profiling.Tests/SamplingTransactionProfilerTests.cs b/test/Sentry.Profiling.Tests/SamplingTransactionProfilerTests.cs

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+// XML namespaces for custom XAML elements defined in the Sentry.Maui assembly (e.g. Bindable Properties)`
	`2`	`+[assembly: XmlnsDefinition("http://schemas.sentry.io/maui", "Sentry.Maui")]`
	`3`	`+[assembly: Microsoft.Maui.Controls.XmlnsPrefix("http://schemas.sentry.io/maui", "sentry")]`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,6 @@ public void UnBind(VisualElement element)`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`		`-`
`33`	`32`	`private void OnButtonOnClicked(object? sender, EventArgs _)`
`34`	`33`	`=> addBreadcrumbCallback?.Invoke(new(sender, nameof(Button.Clicked)));`
`35`	`34`