Centralize rate limit response constants

KSemenenko · KSemenenko · commit 98e9d3a7772c · 2026-05-05T12:28:27.000+02:00
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Extensions/SignalRServerBuilderExtensions.cs b/ManagedCode.Orleans.RateLimiting.Client/Extensions/SignalRServerBuilderExtensions.cs
@@ -15,10 +15,11 @@ public static ISignalRServerBuilder AddOrleansRateLimiting(
         string configurationName,
         RateLimitPartitionKind partitionKind = RateLimitPartitionKind.User)
     {
-        builder.Services.AddOrleansRateLimiting(options => options.AddToPolicy("SignalR", partitionKind, configurationName, required: true));
+        builder.Services.AddOrleansRateLimiting(options =>
+            options.AddToPolicy(SignalRRateLimitingDefaults.PolicyName, partitionKind, configurationName, required: true));
         builder.Services.Configure<SignalRRateLimitingOptions>(options =>
         {
-            options.PolicyName = "SignalR";
+            options.PolicyName = SignalRRateLimitingDefaults.PolicyName;
             options.ConfigurationName = configurationName;
             options.PartitionKind = partitionKind;
         });
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansBaseRateLimitingMiddleware.cs b/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansBaseRateLimitingMiddleware.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Net;
 using System.Reflection;
 using System.Threading.Tasks;
 using ManagedCode.Orleans.RateLimiting.Client.Attributes;
@@ -38,26 +37,14 @@ public async Task Invoke(HttpContext httpContext)
 
         AddLimiters(httpContext, holder);
 
-        // throw too many requests if any of the limiters is null code 429
         var error = await holder.AcquireAsync();
         if (error is null)
         {
             await _next(httpContext);
         }
         else
         {
-            if (httpContext.Response.HasStarted)
-                return;
-
-            httpContext.Response.Clear();
-            httpContext.Response.StatusCode = (int)HttpStatusCode.TooManyRequests;
-            await httpContext.Response.WriteAsJsonAsync(new
-            {
-                StatusCode = (int)HttpStatusCode.TooManyRequests,
-                Error = "Too many requests",
-                error.Reason,
-                RetryAfter = error.RetryAfter.ToString()
-            });
+            await RateLimitResponseWriter.WriteTooManyRequestsAsync(httpContext, error);
         }
     }
 
@@ -95,13 +82,13 @@ protected static (T attribute, string? postfix)? TryGetAttribute<T>(HttpContext
         var limiter = _client.GetRateLimiterByConfig(key, configurationName, _services.GetServices<RateLimiterConfig>());
 
         if (limiter is null)
-            _logger.LogError("Configuration {ConfigurationName} not found for RateLimiter", configurationName);
+            _logger.LogError(RateLimitMiddlewareConstants.ConfigurationNotFoundLogMessage, configurationName);
 
         return limiter;
     }
 
     protected static string CreateKey(params string[] parts)
     {
-        return string.Join(":", parts);
+        return string.Join(RateLimitMiddlewareConstants.KeySeparator, parts);
     }
 }
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansRequestRateLimitingMiddleware.cs b/ManagedCode.Orleans.RateLimiting.Client/Middlewares/OrleansRequestRateLimitingMiddleware.cs
@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using System.Linq;
-using System.Net;
 using System.Security.Claims;
 using System.Threading.Tasks;
 using ManagedCode.Orleans.RateLimiting.Client.Extensions;
@@ -39,39 +38,31 @@ public async Task Invoke(HttpContext httpContext)
             return;
         }
 
-        if (httpContext.Response.HasStarted)
-            return;
-
-        httpContext.Response.Clear();
-        httpContext.Response.StatusCode = (int)HttpStatusCode.TooManyRequests;
-        await httpContext.Response.WriteAsJsonAsync(new
-        {
-            StatusCode = (int)HttpStatusCode.TooManyRequests,
-            Error = "Too many requests",
-            error.Reason,
-            RetryAfter = error.RetryAfter.ToString()
-        });
+        await RateLimitResponseWriter.WriteTooManyRequestsAsync(httpContext, error);
     }
 
     private RateLimitRequestContext CreateContext(HttpContext httpContext)
     {
         var endpoint = httpContext.GetEndpoint();
         var user = httpContext.User;
-        var path = httpContext.Request.Path.Value ?? "/";
+        var path = httpContext.Request.Path.Value ?? RateLimitMiddlewareConstants.DefaultPath;
 
         return new RateLimitRequestContext
         {
-            OperationName = endpoint?.DisplayName ?? $"{httpContext.Request.Method} {path}",
+            OperationName = endpoint?.DisplayName ?? string.Concat(httpContext.Request.Method, RateLimitMiddlewareConstants.OperationNameSeparator, path),
             UserId = user.FindFirstValue(ClaimTypes.NameIdentifier) ?? user.Identity?.Name,
-            GroupId = user.FindFirstValue("group") ?? user.FindFirstValue("groups") ?? user.FindFirstValue(ClaimTypes.GroupSid),
-            TenantId = user.FindFirstValue("tenant_id") ?? user.FindFirstValue("tid"),
+            GroupId = user.FindFirstValue(RateLimitMiddlewareConstants.GroupClaimType)
+                      ?? user.FindFirstValue(RateLimitMiddlewareConstants.GroupsClaimType)
+                      ?? user.FindFirstValue(ClaimTypes.GroupSid),
+            TenantId = user.FindFirstValue(RateLimitMiddlewareConstants.TenantIdClaimType)
+                       ?? user.FindFirstValue(RateLimitMiddlewareConstants.ShortTenantIdClaimType),
             Role = user.Claims.FirstOrDefault(claim => claim.Type == ClaimTypes.Role)?.Value,
             IpAddress = httpContext.Request.GetClientIpAddress(),
             Resource = path,
             Metadata = new Dictionary<string, string>
             {
-                ["method"] = httpContext.Request.Method,
-                ["path"] = path
+                [RateLimitMiddlewareConstants.MethodMetadataKey] = httpContext.Request.Method,
+                [RateLimitMiddlewareConstants.PathMetadataKey] = path
             },
             PolicyName = _policyName
         };
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Middlewares/RateLimitMiddlewareConstants.cs b/ManagedCode.Orleans.RateLimiting.Client/Middlewares/RateLimitMiddlewareConstants.cs
@@ -0,0 +1,20 @@
+namespace ManagedCode.Orleans.RateLimiting.Client.Middlewares;
+
+internal static class RateLimitMiddlewareConstants
+{
+    public const string DefaultPath = "/";
+    public const string KeySeparator = ":";
+    public const string OperationNameSeparator = " ";
+    public const string ResourceSeparator = ".";
+    public const string TooManyRequestsError = "Too many requests";
+    public const string ConfigurationNotFoundLogMessage = "Configuration {ConfigurationName} not found for RateLimiter";
+    public const string GroupClaimType = "group";
+    public const string GroupsClaimType = "groups";
+    public const string TenantIdClaimType = "tenant_id";
+    public const string ShortTenantIdClaimType = "tid";
+    public const string HubMetadataKey = "hub";
+    public const string MethodMetadataKey = "method";
+    public const string ConfigurationMetadataKey = "configuration";
+    public const string PartitionMetadataKey = "partition";
+    public const string PathMetadataKey = "path";
+}
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Middlewares/RateLimitResponseWriter.cs b/ManagedCode.Orleans.RateLimiting.Client/Middlewares/RateLimitResponseWriter.cs
@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using ManagedCode.Orleans.RateLimiting.Core.Models;
+using Microsoft.AspNetCore.Http;
+
+namespace ManagedCode.Orleans.RateLimiting.Client.Middlewares;
+
+internal static class RateLimitResponseWriter
+{
+    public static async Task WriteTooManyRequestsAsync(HttpContext httpContext, OrleansRateLimitLease lease)
+    {
+        if (httpContext.Response.HasStarted)
+            return;
+
+        httpContext.Response.Clear();
+        httpContext.Response.StatusCode = StatusCodes.Status429TooManyRequests;
+        await httpContext.Response.WriteAsJsonAsync(new RateLimitRejectedResponse(
+            StatusCodes.Status429TooManyRequests,
+            RateLimitMiddlewareConstants.TooManyRequestsError,
+            lease.Reason,
+            lease.RetryAfter.ToString()));
+    }
+
+    private sealed record RateLimitRejectedResponse(int StatusCode, string Error, string Reason, string RetryAfter);
+}
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Middlewares/RateLimitingHubFilter.cs b/ManagedCode.Orleans.RateLimiting.Client/Middlewares/RateLimitingHubFilter.cs
@@ -64,17 +64,23 @@ private RateLimitRequestContext CreateContext(HubInvocationContext invocationCon
         {
             OperationName = invocationContext.HubMethodName,
             UserId = userKey,
-            GroupId = user?.FindFirstValue("group") ?? user?.FindFirstValue("groups") ?? user?.FindFirstValue(ClaimTypes.GroupSid),
-            TenantId = user?.FindFirstValue("tenant_id") ?? user?.FindFirstValue("tid"),
+            GroupId = user?.FindFirstValue(RateLimitMiddlewareConstants.GroupClaimType)
+                      ?? user?.FindFirstValue(RateLimitMiddlewareConstants.GroupsClaimType)
+                      ?? user?.FindFirstValue(ClaimTypes.GroupSid),
+            TenantId = user?.FindFirstValue(RateLimitMiddlewareConstants.TenantIdClaimType)
+                       ?? user?.FindFirstValue(RateLimitMiddlewareConstants.ShortTenantIdClaimType),
             Role = user?.FindFirstValue(ClaimTypes.Role),
             IpAddress = httpContext?.Connection.RemoteIpAddress?.ToString(),
-            Resource = $"{invocationContext.Hub.GetType().FullName}.{invocationContext.HubMethodName}",
+            Resource = string.Concat(
+                invocationContext.Hub.GetType().FullName,
+                RateLimitMiddlewareConstants.ResourceSeparator,
+                invocationContext.HubMethodName),
             Metadata = new Dictionary<string, string>
             {
-                ["hub"] = invocationContext.Hub.GetType().FullName ?? invocationContext.Hub.GetType().Name,
-                ["method"] = invocationContext.HubMethodName,
-                ["configuration"] = _options.ConfigurationName,
-                ["partition"] = _options.PartitionKind.ToString()
+                [RateLimitMiddlewareConstants.HubMetadataKey] = invocationContext.Hub.GetType().FullName ?? invocationContext.Hub.GetType().Name,
+                [RateLimitMiddlewareConstants.MethodMetadataKey] = invocationContext.HubMethodName,
+                [RateLimitMiddlewareConstants.ConfigurationMetadataKey] = _options.ConfigurationName,
+                [RateLimitMiddlewareConstants.PartitionMetadataKey] = _options.PartitionKind.ToString()
             },
             PolicyName = _options.PolicyName
         };
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Options/SignalRRateLimitingDefaults.cs b/ManagedCode.Orleans.RateLimiting.Client/Options/SignalRRateLimitingDefaults.cs
@@ -0,0 +1,8 @@
+namespace ManagedCode.Orleans.RateLimiting.Client.Options;
+
+public static class SignalRRateLimitingDefaults
+{
+    public const string PolicyName = "SignalR";
+    public const string ConfigurationName = "SignalR";
+    public const string AnonymousUserKey = "anonymous";
+}
diff --git a/ManagedCode.Orleans.RateLimiting.Client/Options/SignalRRateLimitingOptions.cs b/ManagedCode.Orleans.RateLimiting.Client/Options/SignalRRateLimitingOptions.cs
@@ -4,11 +4,11 @@ namespace ManagedCode.Orleans.RateLimiting.Client.Options;
 
 public sealed class SignalRRateLimitingOptions
 {
-    public string PolicyName { get; set; } = "SignalR";
+    public string PolicyName { get; set; } = SignalRRateLimitingDefaults.PolicyName;
 
-    public string ConfigurationName { get; set; } = "SignalR";
+    public string ConfigurationName { get; set; } = SignalRRateLimitingDefaults.ConfigurationName;
 
     public RateLimitPartitionKind PartitionKind { get; set; } = RateLimitPartitionKind.User;
 
-    public string AnonymousUserKey { get; set; } = "anonymous";
+    public string AnonymousUserKey { get; set; } = SignalRRateLimitingDefaults.AnonymousUserKey;
 }
diff --git a/ManagedCode.Orleans.RateLimiting.Core/Exceptions/RateLimitExceededException.cs b/ManagedCode.Orleans.RateLimiting.Core/Exceptions/RateLimitExceededException.cs
@@ -1,12 +1,13 @@
 using System;
+using ManagedCode.Orleans.RateLimiting.Core.Models;
 
 namespace ManagedCode.Orleans.RateLimiting.Core.Exceptions;
 
 public class RateLimitExceededException : Exception
 {
-    public RateLimitExceededException() : base("Rate limit exceeded")
+    public RateLimitExceededException() : base(RateLimitMetadataNames.RateLimitExceededReason)
     {
-        Reason = "Rate limit exceeded";
+        Reason = RateLimitMetadataNames.RateLimitExceededReason;
         RetryAfter = TimeSpan.Zero;
     }
 
@@ -16,9 +17,9 @@ public RateLimitExceededException(string reason) : base(reason)
         RetryAfter = TimeSpan.Zero;
     }
 
-    public RateLimitExceededException(TimeSpan retry) : base("Time limit exceeded")
+    public RateLimitExceededException(TimeSpan retry) : base(RateLimitMetadataNames.TimeLimitExceededReason)
     {
-        Reason = "Time limit exceeded";
+        Reason = RateLimitMetadataNames.TimeLimitExceededReason;
         RetryAfter = retry;
     }
 
@@ -30,4 +31,4 @@ public RateLimitExceededException(string reason, TimeSpan retry) : base(reason)
 
     public string Reason { get; set; }
     public TimeSpan RetryAfter { get; set; }
-}
+}
diff --git a/ManagedCode.Orleans.RateLimiting.Core/Models/Holders/GroupLimiterHolder.cs b/ManagedCode.Orleans.RateLimiting.Core/Models/Holders/GroupLimiterHolder.cs
@@ -7,6 +7,8 @@ namespace ManagedCode.Orleans.RateLimiting.Core.Models.Holders;
 
 public class GroupLimiterHolder : IAsyncDisposable
 {
+    private const string AlreadyAcquiredMessage = "A limiter group can only be acquired once before it is disposed.";
+
     private readonly List<LimiterEntry> _holders = [];
     private bool _acquired;
     private bool _disposed;
@@ -41,7 +43,7 @@ public bool AddLimiter(ILimiterHolder? holder)
         ObjectDisposedException.ThrowIf(_disposed, this);
 
         if (_acquired)
-            throw new InvalidOperationException("A limiter group can only be acquired once before it is disposed.");
+            throw new InvalidOperationException(AlreadyAcquiredMessage);
 
         for (var index = 0; index < _holders.Count; index++)
         {
diff --git a/ManagedCode.Orleans.RateLimiting.Core/Models/OrleansRateLimitLease.cs b/ManagedCode.Orleans.RateLimiting.Core/Models/OrleansRateLimitLease.cs
@@ -31,10 +31,13 @@ public OrleansRateLimitLease(RateLimitLeaseMetadata metadata, IGrainFactory grai
 
     public IGrainFactory GrainFactory { get; init; }
 
-    public string Reason => TryGetMetadata("REASON_PHRASE", out var reason) ? reason ?? string.Empty : "Rate limit exceeded";
+    public string Reason =>
+        TryGetMetadata(RateLimitMetadataNames.ReasonPhrase, out var reason) ? reason ?? string.Empty : RateLimitMetadataNames.RateLimitExceededReason;
 
     public TimeSpan RetryAfter =>
-        TryGetMetadata("RETRY_AFTER", out var reason) && TimeSpan.TryParse(reason, CultureInfo.InvariantCulture, out var retryAfter) ? retryAfter : TimeSpan.Zero;
+        TryGetMetadata(RateLimitMetadataNames.RetryAfter, out var reason) && TimeSpan.TryParse(reason, CultureInfo.InvariantCulture, out var retryAfter)
+            ? retryAfter
+            : TimeSpan.Zero;
 
     public bool IsAcquired { get; init; }
 
diff --git a/ManagedCode.Orleans.RateLimiting.Core/Models/RateLimitLeaseMetadata.cs b/ManagedCode.Orleans.RateLimiting.Core/Models/RateLimitLeaseMetadata.cs
@@ -23,7 +23,7 @@ public RateLimitLeaseMetadata(GrainId grainId)
         LeaseId = Guid.Empty;
         GrainId = grainId;
         IsAcquired = false;
-        Metadata = [new KeyValuePair<string, object?>("REASON_PHRASE", "Lease not acquired")];
+        Metadata = [new KeyValuePair<string, object?>(RateLimitMetadataNames.ReasonPhrase, RateLimitMetadataNames.LeaseNotAcquiredReason)];
     }
 
     [Id(0)]
diff --git a/ManagedCode.Orleans.RateLimiting.Core/Models/RateLimitMetadataNames.cs b/ManagedCode.Orleans.RateLimiting.Core/Models/RateLimitMetadataNames.cs
@@ -0,0 +1,10 @@
+namespace ManagedCode.Orleans.RateLimiting.Core.Models;
+
+public static class RateLimitMetadataNames
+{
+    public const string ReasonPhrase = "REASON_PHRASE";
+    public const string RetryAfter = "RETRY_AFTER";
+    public const string LeaseNotAcquiredReason = "Lease not acquired";
+    public const string RateLimitExceededReason = "Rate limit exceeded";
+    public const string TimeLimitExceededReason = "Time limit exceeded";
+}

Original file line number	Diff line number	Diff line change
`@@ -15,10 +15,11 @@ public static ISignalRServerBuilder AddOrleansRateLimiting(`
`15`	`15`	`string configurationName,`
`16`	`16`	`RateLimitPartitionKind partitionKind = RateLimitPartitionKind.User)`
`17`	`17`	`{`
`18`		`- builder.Services.AddOrleansRateLimiting(options => options.AddToPolicy("SignalR", partitionKind, configurationName, required: true));`
	`18`	`+ builder.Services.AddOrleansRateLimiting(options =>`
	`19`	`+ options.AddToPolicy(SignalRRateLimitingDefaults.PolicyName, partitionKind, configurationName, required: true));`
`19`	`20`	`builder.Services.Configure<SignalRRateLimitingOptions>(options =>`
`20`	`21`	`{`
`21`		`- options.PolicyName = "SignalR";`
	`22`	`+ options.PolicyName = SignalRRateLimitingDefaults.PolicyName;`
`22`	`23`	`options.ConfigurationName = configurationName;`
`23`	`24`	`options.PartitionKind = partitionKind;`
`24`	`25`	`});`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`using System;`
`2`	`2`	`using System.Collections.Generic;`
`3`		`-using System.Net;`
`4`	`3`	`using System.Reflection;`
`5`	`4`	`using System.Threading.Tasks;`
`6`	`5`	`using ManagedCode.Orleans.RateLimiting.Client.Attributes;`
`@@ -38,26 +37,14 @@ public async Task Invoke(HttpContext httpContext)`
`38`	`37`
`39`	`38`	`AddLimiters(httpContext, holder);`
`40`	`39`
`41`		`- // throw too many requests if any of the limiters is null code 429`
`42`	`40`	`var error = await holder.AcquireAsync();`
`43`	`41`	`if (error is null)`
`44`	`42`	`{`
`45`	`43`	`await _next(httpContext);`
`46`	`44`	`}`
`47`	`45`	`else`
`48`	`46`	`{`
`49`		`- if (httpContext.Response.HasStarted)`
`50`		`- return;`
`51`		`-`
`52`		`- httpContext.Response.Clear();`
`53`		`- httpContext.Response.StatusCode = (int)HttpStatusCode.TooManyRequests;`
`54`		`- await httpContext.Response.WriteAsJsonAsync(new`
`55`		`- {`
`56`		`- StatusCode = (int)HttpStatusCode.TooManyRequests,`
`57`		`- Error = "Too many requests",`
`58`		`- error.Reason,`
`59`		`- RetryAfter = error.RetryAfter.ToString()`
`60`		`- });`
	`47`	`+ await RateLimitResponseWriter.WriteTooManyRequestsAsync(httpContext, error);`
`61`	`48`	`}`
`62`	`49`	`}`
`63`	`50`
`@@ -95,13 +82,13 @@ protected static (T attribute, string? postfix)? TryGetAttribute<T>(HttpContext`
`95`	`82`	`var limiter = _client.GetRateLimiterByConfig(key, configurationName, _services.GetServices<RateLimiterConfig>());`
`96`	`83`
`97`	`84`	`if (limiter is null)`
`98`		`- _logger.LogError("Configuration {ConfigurationName} not found for RateLimiter", configurationName);`
	`85`	`+ _logger.LogError(RateLimitMiddlewareConstants.ConfigurationNotFoundLogMessage, configurationName);`
`99`	`86`
`100`	`87`	`return limiter;`
`101`	`88`	`}`
`102`	`89`
`103`	`90`	`protected static string CreateKey(params string[] parts)`
`104`	`91`	`{`
`105`		`- return string.Join(":", parts);`
	`92`	`+ return string.Join(RateLimitMiddlewareConstants.KeySeparator, parts);`
`106`	`93`	`}`
`107`	`94`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,11 +4,11 @@ namespace ManagedCode.Orleans.RateLimiting.Client.Options;`
`4`	`4`
`5`	`5`	`public sealed class SignalRRateLimitingOptions`
`6`	`6`	`{`
`7`		`- public string PolicyName { get; set; } = "SignalR";`
	`7`	`+ public string PolicyName { get; set; } = SignalRRateLimitingDefaults.PolicyName;`
`8`	`8`
`9`		`- public string ConfigurationName { get; set; } = "SignalR";`
	`9`	`+ public string ConfigurationName { get; set; } = SignalRRateLimitingDefaults.ConfigurationName;`
`10`	`10`
`11`	`11`	`public RateLimitPartitionKind PartitionKind { get; set; } = RateLimitPartitionKind.User;`
`12`	`12`
`13`		`- public string AnonymousUserKey { get; set; } = "anonymous";`
	`13`	`+ public string AnonymousUserKey { get; set; } = SignalRRateLimitingDefaults.AnonymousUserKey;`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,12 +1,13 @@`
`1`	`1`	`using System;`
	`2`	`+using ManagedCode.Orleans.RateLimiting.Core.Models;`
`2`	`3`
`3`	`4`	`namespace ManagedCode.Orleans.RateLimiting.Core.Exceptions;`
`4`	`5`
`5`	`6`	`public class RateLimitExceededException : Exception`
`6`	`7`	`{`
`7`		`- public RateLimitExceededException() : base("Rate limit exceeded")`
	`8`	`+ public RateLimitExceededException() : base(RateLimitMetadataNames.RateLimitExceededReason)`
`8`	`9`	`{`
`9`		`- Reason = "Rate limit exceeded";`
	`10`	`+ Reason = RateLimitMetadataNames.RateLimitExceededReason;`
`10`	`11`	`RetryAfter = TimeSpan.Zero;`
`11`	`12`	`}`
`12`	`13`
`@@ -16,9 +17,9 @@ public RateLimitExceededException(string reason) : base(reason)`
`16`	`17`	`RetryAfter = TimeSpan.Zero;`
`17`	`18`	`}`
`18`	`19`
`19`		`- public RateLimitExceededException(TimeSpan retry) : base("Time limit exceeded")`
	`20`	`+ public RateLimitExceededException(TimeSpan retry) : base(RateLimitMetadataNames.TimeLimitExceededReason)`
`20`	`21`	`{`
`21`		`- Reason = "Time limit exceeded";`
	`22`	`+ Reason = RateLimitMetadataNames.TimeLimitExceededReason;`
`22`	`23`	`RetryAfter = retry;`
`23`	`24`	`}`
`24`	`25`
`@@ -30,4 +31,4 @@ public RateLimitExceededException(string reason, TimeSpan retry) : base(reason)`
`30`	`31`
`31`	`32`	`public string Reason { get; set; }`
`32`	`33`	`public TimeSpan RetryAfter { get; set; }`
`33`		`-}`
	`34`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,8 @@ namespace ManagedCode.Orleans.RateLimiting.Core.Models.Holders;`
`7`	`7`
`8`	`8`	`public class GroupLimiterHolder : IAsyncDisposable`
`9`	`9`	`{`
	`10`	`+ private const string AlreadyAcquiredMessage = "A limiter group can only be acquired once before it is disposed.";`
	`11`	`+`
`10`	`12`	`private readonly List<LimiterEntry> _holders = [];`
`11`	`13`	`private bool _acquired;`
`12`	`14`	`private bool _disposed;`
`@@ -41,7 +43,7 @@ public bool AddLimiter(ILimiterHolder? holder)`
`41`	`43`	`ObjectDisposedException.ThrowIf(_disposed, this);`
`42`	`44`
`43`	`45`	`if (_acquired)`
`44`		`- throw new InvalidOperationException("A limiter group can only be acquired once before it is disposed.");`
	`46`	`+ throw new InvalidOperationException(AlreadyAcquiredMessage);`
`45`	`47`
`46`	`48`	`for (var index = 0; index < _holders.Count; index++)`
`47`	`49`	`{`