Fix code style warnings and improve timing accuracy

Fix: Ensure ObserverCircuitBreaker.failureThreshold is at least 1 when circuit breaker is enabled (health tracker allows 0 to disable tracking entirely)
Convert backing fields to auto properties (IDE0032):
SignalRGroupCoordinatorGrain: GroupPartitions, GroupMembership
ExpiringObserverBuffer: MessageCount
ObserverCircuitBreaker: LastException
ObserverHealthTracker: CircuitBreakerEnabled, LastException, IsDead
Convert classes to primary constructors (IDE0290)
Add editorconfig suppressions for SignalRConnectionHeartbeatGrain ([PersistentState] incompatible with primary constructors)
Replace DateTime.UtcNow with Stopwatch.GetTimestamp() for elapsed time measurements in circuit breaker, health tracker, and grace period buffer to prevent timing issues from system clock adjustments

Author: Paul Cernuto

.claude/settings.local.json

@@ -3,7 +3,10 @@
     "allow": [
       "Bash(tree:*)",
       "Bash(dotnet build:*)",
-      "Bash(dotnet test:*)"
+      "Bash(dotnet test:*)",
+      "Bash(git checkout:*)",
+      "Bash(git push:*)",
+      "Bash(git remote add:*)"
     ]
   }
 }

.editorconfig

@@ -453,6 +453,20 @@ dotnet_diagnostic.IDE0200.severity = warning
 dotnet_style_allow_multiple_blank_lines_experimental = false
 dotnet_diagnostic.IDE2000.severity = warning
 
+# SignalR Hub methods are called by string name from clients - suppress async naming rule
+[**/Hubs/*.cs]
+dotnet_naming_rule.async_methods_should_end_with_async.severity = none
+
+# ASP.NET Controller actions don't typically follow async naming conventions
+[**/Controllers/*.cs]
+dotnet_naming_rule.async_methods_should_end_with_async.severity = none
+
+# Orleans grains with [PersistentState] attributes cannot use primary constructors
+# because attributes on constructor parameters cannot be applied to primary constructor parameters
+[**/SignalRConnectionHeartbeatGrain.cs]
+csharp_style_prefer_primary_constructors = false:none
+dotnet_diagnostic.IDE0290.severity = none
+
 # Verify settings for test files
 [*.{received,verified}.{txt,xml,json}]
 charset = utf-8-bom

.gitignore

@@ -646,4 +646,7 @@ MigrationBackup/
 # Ionide (cross platform F# VS Code tools) working folder
 .ionide/
 
-# End of https://www.toptal.com/developers/gitignore/api/intellij,intellij+all,macos,linux,windows,visualstudio,visualstudiocode,rider
+# End of https://www.toptal.com/developers/gitignore/api/intellij,intellij+all,macos,linux,windows,visualstudio,visualstudiocode,rider
+
+# Claude Code temporary directories
+tmpclaude-*/

ManagedCode.Orleans.SignalR.Core/Helpers/CollectionPool.cs

@@ -12,16 +12,16 @@ public static class CollectionPool
 {
     private const int MaxPoolSize = 256;
 
-    private static readonly ConcurrentBag<HashSet<string>> StringHashSetPool = new();
-    private static readonly ConcurrentBag<List<string>> StringListPool = new();
-    private static readonly ConcurrentBag<Dictionary<int, List<string>>> IntListDictionaryPool = new();
+    private static readonly ConcurrentBag<HashSet<string>> _stringHashSetPool = new();
+    private static readonly ConcurrentBag<List<string>> _stringListPool = new();
+    private static readonly ConcurrentBag<Dictionary<int, List<string>>> _intListDictionaryPool = new();
 
     /// <summary>
     /// Gets a HashSet&lt;string&gt; from the pool or creates a new one.
     /// </summary>
     public static HashSet<string> GetStringHashSet()
     {
-        if (StringHashSetPool.TryTake(out var set))
+        if (_stringHashSetPool.TryTake(out var set))
         {
             return set;
         }
@@ -34,21 +34,21 @@ public static HashSet<string> GetStringHashSet()
     /// </summary>
     public static void Return(HashSet<string> set)
     {
-        if (set is null || StringHashSetPool.Count >= MaxPoolSize)
+        if (set is null || _stringHashSetPool.Count >= MaxPoolSize)
         {
             return;
         }
 
         set.Clear();
-        StringHashSetPool.Add(set);
+        _stringHashSetPool.Add(set);
     }
 
     /// <summary>
     /// Gets a List&lt;string&gt; from the pool or creates a new one.
     /// </summary>
     public static List<string> GetStringList()
     {
-        if (StringListPool.TryTake(out var list))
+        if (_stringListPool.TryTake(out var list))
         {
             return list;
         }
@@ -61,7 +61,7 @@ public static List<string> GetStringList()
     /// </summary>
     public static List<string> GetStringList(int capacity)
     {
-        if (StringListPool.TryTake(out var list))
+        if (_stringListPool.TryTake(out var list))
         {
             if (list.Capacity < capacity)
             {
@@ -78,21 +78,21 @@ public static List<string> GetStringList(int capacity)
     /// </summary>
     public static void Return(List<string> list)
     {
-        if (list is null || StringListPool.Count >= MaxPoolSize)
+        if (list is null || _stringListPool.Count >= MaxPoolSize)
         {
             return;
         }
 
         list.Clear();
-        StringListPool.Add(list);
+        _stringListPool.Add(list);
     }
 
     /// <summary>
     /// Gets a Dictionary&lt;int, List&lt;string&gt;&gt; from the pool.
     /// </summary>
     public static Dictionary<int, List<string>> GetIntListDictionary()
     {
-        if (IntListDictionaryPool.TryTake(out var dict))
+        if (_intListDictionaryPool.TryTake(out var dict))
         {
             return dict;
         }
@@ -106,7 +106,7 @@ public static Dictionary<int, List<string>> GetIntListDictionary()
     /// </summary>
     public static void Return(Dictionary<int, List<string>> dict)
     {
-        if (dict is null || IntListDictionaryPool.Count >= MaxPoolSize)
+        if (dict is null || _intListDictionaryPool.Count >= MaxPoolSize)
         {
             return;
         }
@@ -118,20 +118,15 @@ public static void Return(Dictionary<int, List<string>> dict)
         }
 
         dict.Clear();
-        IntListDictionaryPool.Add(dict);
+        _intListDictionaryPool.Add(dict);
     }
 
     /// <summary>
     /// A scope that automatically returns a HashSet to the pool when disposed.
     /// </summary>
-    public readonly struct HashSetScope : IDisposable
+    public readonly struct HashSetScope(HashSet<string> set) : IDisposable
     {
-        public HashSet<string> Set { get; }
-
-        public HashSetScope(HashSet<string> set)
-        {
-            Set = set;
-        }
+        public HashSet<string> Set { get; } = set;
 
         public void Dispose()
         {
@@ -142,14 +137,9 @@ public void Dispose()
     /// <summary>
     /// A scope that automatically returns a List to the pool when disposed.
     /// </summary>
-    public readonly struct ListScope : IDisposable
+    public readonly struct ListScope(List<string> list) : IDisposable
     {
-        public List<string> List { get; }
-
-        public ListScope(List<string> list)
-        {
-            List = list;
-        }
+        public List<string> List { get; } = list;
 
         public void Dispose()
         {

ManagedCode.Orleans.SignalR.Core/Helpers/PartitionHelper.cs

@@ -15,15 +15,15 @@ public static class PartitionHelper
 {
     private const int VirtualNodesPerPartition = 150; // Number of virtual nodes per physical partition
     private const int MaxStackAllocSize = 256; // Max bytes for stackalloc
-    private static readonly ConcurrentDictionary<RingCacheKey, ConsistentHashRing> RingCache = new();
+    private static readonly ConcurrentDictionary<_ringCacheKey, ConsistentHashRing> _ringCache = new();
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
     public static int GetPartitionId(string connectionId, uint partitionCount)
     {
         ArgumentException.ThrowIfNullOrEmpty(connectionId);
         ArgumentOutOfRangeException.ThrowIfZero(partitionCount);
 
-        var ring = RingCache.GetOrAdd(new RingCacheKey((int)partitionCount, VirtualNodesPerPartition),
+        var ring = _ringCache.GetOrAdd(new _ringCacheKey((int)partitionCount, VirtualNodesPerPartition),
             static key => new ConsistentHashRing(key.PartitionCount, key.VirtualNodes));
 
         return ring.GetPartition(connectionId);
@@ -84,7 +84,7 @@ internal static uint ComputeHash(ReadOnlySpan<char> key)
         }
     }
 
-    private readonly record struct RingCacheKey(int PartitionCount, int VirtualNodes);
+    private readonly record struct _ringCacheKey(int PartitionCount, int VirtualNodes);
 }
 
 public sealed class ConsistentHashRing

ManagedCode.Orleans.SignalR.Core/Helpers/RetryHelper.cs

@@ -1,7 +1,7 @@
-using Orleans.Runtime;
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using Orleans.Runtime;
 
 namespace ManagedCode.Orleans.SignalR.Core.Helpers;
 
@@ -195,7 +195,7 @@ public RetryPolicy(int maxAttempts, TimeSpan initialDelay, TimeSpan maxDelay, do
     {
         MaxAttempts = Math.Max(1, maxAttempts);
         InitialDelay = initialDelay > TimeSpan.Zero ? initialDelay : TimeSpan.FromMilliseconds(100);
-        MaxDelay = maxDelay > initialDelay ? maxDelay : TimeSpan.FromSeconds(30);
+        MaxDelay = maxDelay > InitialDelay ? maxDelay : TimeSpan.FromSeconds(30);
         ExponentialBase = Math.Max(1.1, exponentialBase);
     }
 

ManagedCode.Orleans.SignalR.Core/Helpers/TimeIntervalHelper.cs

@@ -1,8 +1,8 @@
+using System;
+using System.Threading;
 using ManagedCode.Orleans.SignalR.Core.Config;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.Extensions.Options;
-using System;
-using System.Threading;
 
 namespace ManagedCode.Orleans.SignalR.Core.Helpers;
 

ManagedCode.Orleans.SignalR.Core/HubContext/OrleansHubClients.cs

@@ -1,5 +1,5 @@
-using Microsoft.AspNetCore.SignalR;
 using System.Collections.Generic;
+using Microsoft.AspNetCore.SignalR;
 
 namespace ManagedCode.Orleans.SignalR.Core.HubContext;
 

ManagedCode.Orleans.SignalR.Core/HubContext/TypedClientBuilder.cs

@@ -1,11 +1,11 @@
-using Microsoft.AspNetCore.SignalR;
 using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.SignalR;
 
 namespace ManagedCode.Orleans.SignalR.Core.HubContext;
 
@@ -16,12 +16,12 @@ internal static class TypedClientBuilder<T>
     // There is one static instance of _builder per T
     private static readonly Lazy<Func<IClientProxy, T>> _builder = new(GenerateClientBuilder);
 
-    private static readonly PropertyInfo CancellationTokenNoneProperty =
+    private static readonly PropertyInfo _cancellationTokenNoneProperty =
         typeof(CancellationToken).GetProperty("None", BindingFlags.Public | BindingFlags.Static)!;
 
-    private static readonly ConstructorInfo ObjectConstructor = typeof(object).GetConstructors().Single();
+    private static readonly ConstructorInfo _objectConstructor = typeof(object).GetConstructors().Single();
 
-    private static readonly Type[] ParameterTypes = [typeof(IClientProxy)];
+    private static readonly Type[] _parameterTypes = [typeof(IClientProxy)];
 
     public static T Build(IClientProxy proxy)
     {
@@ -89,13 +89,13 @@ private static IEnumerable<MethodInfo> GetAllInterfaceMethods(Type interfaceType
 
     private static ConstructorInfo BuildConstructor(TypeBuilder type, FieldInfo proxyField)
     {
-        var ctor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, ParameterTypes);
+        var ctor = type.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, _parameterTypes);
 
         var generator = ctor.GetILGenerator();
 
         // Call object constructor
         generator.Emit(OpCodes.Ldarg_0);
-        generator.Emit(OpCodes.Call, ObjectConstructor);
+        generator.Emit(OpCodes.Call, _objectConstructor);
 
         // Assign constructor argument to the proxyField
         generator.Emit(OpCodes.Ldarg_0); // type
@@ -217,7 +217,7 @@ private static void BuildMethod(TypeBuilder type, MethodInfo interfaceMethodInfo
         else
         {
             // Get 'CancellationToken.None' and put it on the stack, for when method does not have CancellationToken
-            generator.Emit(OpCodes.Call, CancellationTokenNoneProperty.GetMethod!);
+            generator.Emit(OpCodes.Call, _cancellationTokenNoneProperty.GetMethod!);
         }
 
         // Send!
@@ -229,7 +229,7 @@ private static void BuildMethod(TypeBuilder type, MethodInfo interfaceMethodInfo
     private static void BuildFactoryMethod(TypeBuilder type, ConstructorInfo ctor)
     {
         var method = type.DefineMethod(nameof(Build), MethodAttributes.Public | MethodAttributes.Static,
-            CallingConventions.Standard, typeof(T), ParameterTypes);
+            CallingConventions.Standard, typeof(T), _parameterTypes);
 
         var generator = method.GetILGenerator();
 

ManagedCode.Orleans.SignalR.Core/Interfaces/IObserverConnectionManager.cs

@@ -1,6 +1,6 @@
+using System.Threading.Tasks;
 using Orleans;
 using Orleans.Concurrency;
-using System.Threading.Tasks;
 
 namespace ManagedCode.Orleans.SignalR.Core.Interfaces;