Changed all cases where int (or in one case long) was used instead of bool because of the lack of support in Interlocked.Exchange/CompareExchange to use the now-supported type, but with backwards-compatible support for .NET pre-9.0.

Author: logiclrd

src/Sentry.EntityFramework/SentryDatabaseLogging.cs

@@ -5,14 +5,24 @@ namespace Sentry.EntityFramework;
 /// </summary>
 internal static class SentryDatabaseLogging
 {
-    private static int Init;
+#if NET9_0_OR_GREATER
+    private static bool _init;
+
+    const bool TRUE = true;
+    const bool FALSE = false;
+#else
+    private static int _init;
+
+    const int TRUE = 1;
+    const int FALSE = 0;
+#endif
 
     internal static SentryCommandInterceptor? UseBreadcrumbs(
         IQueryLogger? queryLogger = null,
         bool initOnce = true,
         IDiagnosticLogger? diagnosticLogger = null)
     {
-        if (initOnce && Interlocked.Exchange(ref Init, 1) != 0)
+        if (initOnce && Interlocked.Exchange(ref _init, TRUE) != FALSE)
         {
             diagnosticLogger?.LogWarning("{0}.{1} was already executed.",
                 nameof(SentryDatabaseLogging), nameof(UseBreadcrumbs));

src/Sentry.Profiling/SampleProfilerSession.cs

@@ -56,18 +56,27 @@ private SampleProfilerSession(SentryStopwatch stopwatch, EventPipeSession sessio
 
     public TraceLog TraceLog => EventSource.TraceLog;
 
-    // default is false, set 1 for true.
-    private static int _throwOnNextStartupForTests = 0;
+#if NET9_0_OR_GREATER
+    private static bool _throwOnNextStartupForTests = FALSE;
+
+    const bool TRUE = true;
+    const bool FALSE = false;
+#else
+    private static int _throwOnNextStartupForTests = FALSE;
+
+    const int TRUE = 1;
+    const int FALSE = 0;
+#endif
 
     internal static bool ThrowOnNextStartupForTests
     {
-        get { return Interlocked.CompareExchange(ref _throwOnNextStartupForTests, 1, 1) == 1; }
+        get { return _throwOnNextStartupForTests != FALSE; }
         set
         {
             if (value)
-                Interlocked.CompareExchange(ref _throwOnNextStartupForTests, 1, 0);
+                Interlocked.CompareExchange(ref _throwOnNextStartupForTests, TRUE, FALSE);
             else
-                Interlocked.CompareExchange(ref _throwOnNextStartupForTests, 0, 1);
+                Interlocked.CompareExchange(ref _throwOnNextStartupForTests, FALSE, TRUE);
         }
     }
 
@@ -77,7 +86,7 @@ public static SampleProfilerSession StartNew(IDiagnosticLogger? logger = null)
         {
             var client = new DiagnosticsClient(Environment.ProcessId);
 
-            if (Interlocked.CompareExchange(ref _throwOnNextStartupForTests, 0, 1) == 1)
+            if (Interlocked.CompareExchange(ref _throwOnNextStartupForTests, FALSE, TRUE) == TRUE)
             {
                 throw new Exception("Test exception");
             }

src/Sentry.Profiling/SamplingTransactionProfilerFactory.cs

@@ -6,14 +6,21 @@ namespace Sentry.Profiling;
 internal class SamplingTransactionProfilerFactory : IDisposable, ITransactionProfilerFactory
 {
     // We only allow a single profile so let's keep track of the current status.
+#if NET9_0_OR_GREATER
+    internal bool _inProgress = FALSE;
+
+    const bool TRUE = true;
+    const bool FALSE = false;
+#else
     internal int _inProgress = FALSE;
 
+    const int TRUE = 1;
+    const int FALSE = 0;
+#endif
+
     // Whether the session startup took longer than the given timeout.
     internal bool StartupTimedOut { get; }
 
-    private const int TRUE = 1;
-    private const int FALSE = 0;
-
     // Stop profiling after the given number of milliseconds.
     private const int TIME_LIMIT_MS = 30_000;
 

src/Sentry/Ben.BlockingDetector/DetectBlockingSynchronizationContext.cs

@@ -10,8 +10,8 @@ internal sealed class DetectBlockingSynchronizationContext : SynchronizationCont
 
         internal int _isSuppressed;
 
-        internal void Suppress() => Interlocked.Exchange(ref _isSuppressed, _isSuppressed + 1);
-        internal void Restore() => Interlocked.Exchange(ref _isSuppressed, _isSuppressed - 1);
+        internal void Suppress() => Interlocked.Increment(ref _isSuppressed);
+        internal void Restore() => Interlocked.Decrement(ref _isSuppressed);
 
         public DetectBlockingSynchronizationContext(IBlockingMonitor monitor)
         {

src/Sentry/Internal/Hub.cs

@@ -24,15 +24,30 @@ internal class Hub : IHub, IDisposable
     private readonly MemoryMonitor? _memoryMonitor;
 #endif
 
+#if NET9_0_OR_GREATER
+    private bool _isPersistedSessionRecovered;
+
+    const bool TRUE = true;
+    const bool FALSE = false;
+#else
     private int _isPersistedSessionRecovered;
 
+    const int TRUE = 1;
+    const int FALSE = 0;
+#endif
+
     // Internal for testability
     internal ConditionalWeakTable<Exception, ISpan> ExceptionToSpanMap { get; } = new();
 
     internal IInternalScopeManager ScopeManager { get; }
 
-    private int _isEnabled = 1;
-    public bool IsEnabled => _isEnabled == 1;
+#if NET9_0_OR_GREATER
+    private bool _isEnabled = TRUE;
+#else
+    private int _isEnabled = TRUE;
+#endif
+
+    public bool IsEnabled => _isEnabled != FALSE;
 
     internal SentryOptions Options => _options;
 
@@ -356,7 +371,7 @@ public TransactionContext ContinueTrace(
     public void StartSession()
     {
         // Attempt to recover persisted session left over from previous run
-        if (Interlocked.Exchange(ref _isPersistedSessionRecovered, 1) != 1)
+        if (Interlocked.Exchange(ref _isPersistedSessionRecovered, TRUE) != TRUE)
         {
             try
             {
@@ -835,7 +850,7 @@ public void Dispose()
     {
         _options.LogInfo("Disposing the Hub.");
 
-        if (Interlocked.Exchange(ref _isEnabled, 0) != 1)
+        if (Interlocked.Exchange(ref _isEnabled, FALSE) != TRUE)
         {
             return;
         }

src/Sentry/Threading/ScopedCountdownLock.cs

@@ -13,12 +13,23 @@ namespace Sentry.Threading;
 internal sealed class ScopedCountdownLock : IDisposable
 {
     private readonly CountdownEvent _event;
+
+#if NET9_0_OR_GREATER
+    private volatile bool _isEngaged;
+
+    const bool TRUE = true;
+    const bool FALSE = false;
+#else
     private volatile int _isEngaged;
 
+    const int TRUE = 1;
+    const int FALSE = 0;
+#endif
+
     internal ScopedCountdownLock()
     {
         _event = new CountdownEvent(1);
-        _isEngaged = 0;
+        _isEngaged = FALSE;
     }
 
     /// <summary>
@@ -31,13 +42,13 @@ internal ScopedCountdownLock()
     /// Gets the number of remaining <see cref="CounterScope"/> required to exit in order to set/signal the event while a <see cref="LockScope"/> is active.
     /// When <see langword="0"/> and while a <see cref="LockScope"/> is active, no more <see cref="CounterScope"/> can be entered.
     /// </summary>
-    internal int Count => _isEngaged == 1 ? _event.CurrentCount : _event.CurrentCount - 1;
+    internal int Count => _isEngaged == TRUE ? _event.CurrentCount : _event.CurrentCount - 1;
 
     /// <summary>
     /// Returns <see langword="true"/> when a <see cref="LockScope"/> is active and the event can be set/signaled by <see cref="Count"/> reaching <see langword="0"/>.
     /// Returns <see langword="false"/> when the <see cref="Count"/> can only reach the initial count of <see langword="1"/> when no <see cref="CounterScope"/> is active any longer.
     /// </summary>
-    internal bool IsEngaged => _isEngaged == 1;
+    internal bool IsEngaged => _isEngaged == TRUE;
 
     /// <summary>
     /// No <see cref="CounterScope"/> will be entered when the <see cref="Count"/> has reached <see langword="0"/>, or while the lock is engaged via an active <see cref="LockScope"/>.
@@ -79,7 +90,7 @@ private void ExitCounterScope()
     /// </remarks>
     internal LockScope TryEnterLockScope()
     {
-        if (Interlocked.CompareExchange(ref _isEngaged, 1, 0) == 0)
+        if (Interlocked.CompareExchange(ref _isEngaged, TRUE, FALSE) == FALSE)
         {
             Debug.Assert(_event.CurrentCount >= 1);
             _ = _event.Signal(); // decrement the initial count of 1, so that the event can be set with the count reaching 0 when all entered 'CounterScope' instances have exited
@@ -94,7 +105,7 @@ private void ExitLockScope()
         Debug.Assert(_event.IsSet);
         _event.Reset(); // reset the signaled event to the initial count of 1, so that new 'CounterScope' instances can be entered again
 
-        if (Interlocked.CompareExchange(ref _isEngaged, 0, 1) != 1)
+        if (Interlocked.CompareExchange(ref _isEngaged, FALSE, TRUE) != TRUE)
         {
             Debug.Fail("The Lock should have not been disengaged without being engaged first.");
         }

src/Sentry/TransactionTracer.cs

@@ -12,9 +12,20 @@ public class TransactionTracer : IBaseTracer, ITransactionTracer
     private readonly IHub _hub;
     private readonly SentryOptions? _options;
     private readonly Timer? _idleTimer;
-    private long _cancelIdleTimeout;
     private readonly SentryStopwatch _stopwatch = SentryStopwatch.StartNew();
 
+#if NET9_0_OR_GREATER
+    private bool _cancelIdleTimeout;
+
+    const bool TRUE = true;
+    const bool FALSE = false;
+#else
+    private int _cancelIdleTimeout;
+
+    const int TRUE = 1;
+    const int FALSE = 0;
+#endif
+
     private readonly Instrumenter _instrumenter = Instrumenter.Sentry;
 
     bool IBaseTracer.IsOtelInstrumenter => _instrumenter == Instrumenter.OpenTelemetry;
@@ -247,7 +258,7 @@ internal TransactionTracer(IHub hub, ITransactionContext context, TimeSpan? idle
         // Set idle timer only if an idle timeout has been provided directly
         if (idleTimeout.HasValue)
         {
-            _cancelIdleTimeout = 1;  // Timer will be cancelled once, atomically setting this back to 0
+            _cancelIdleTimeout = TRUE;  // Timer will be cancelled once, atomically setting this back to false
             _idleTimer = new Timer(state =>
             {
                 if (state is not TransactionTracer transactionTracer)
@@ -362,7 +373,7 @@ public void Clear()
     public void Finish()
     {
         _options?.LogDebug("Attempting to finish Transaction {0}.", SpanId);
-        if (Interlocked.Exchange(ref _cancelIdleTimeout, 0) == 1)
+        if (Interlocked.Exchange(ref _cancelIdleTimeout, FALSE) == TRUE)
         {
             _options?.LogDebug("Disposing of idle timer for Transaction {0}.", SpanId);
             _idleTimer?.Change(Timeout.InfiniteTimeSpan, Timeout.InfiniteTimeSpan);