Improve request rate limiter in multi threaded scenarios

Author: Matthiee

FinancialModelingPrepApi/Abstractions/Http/IRequestRateLimiter.cs

@@ -1,10 +1,11 @@
-using System.Threading.Tasks;
+using System;
+using System.Threading.Tasks;
 
 namespace MatthiWare.FinancialModelingPrep.Abstractions.Http
 {
     public interface IRequestRateLimiter
     {
-        public Task ThrottleAsync();
+        public Task<(bool wasThrottled, TimeSpan totalDelay)> ThrottleAsync();
         public void ReleaseThrottle();
     }
 }

FinancialModelingPrepApi/Core/Http/FinancialModelingPrepHttpClient.cs

@@ -1,6 +1,7 @@
 using MatthiWare.FinancialModelingPrep.Abstractions.Http;
 using MatthiWare.FinancialModelingPrep.Model;
 using MatthiWare.FinancialModelingPrep.Model.Error;
+using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Specialized;
 using System.Net.Http;
@@ -14,15 +15,19 @@ public class FinancialModelingPrepHttpClient
         private readonly HttpClient client;
         private readonly FinancialModelingPrepOptions options;
         private readonly IRequestRateLimiter rateLimiter;
+        private readonly ILogger<FinancialModelingPrepHttpClient> logger;
         private readonly JsonSerializerOptions jsonSerializerOptions;
         private const string EmptyArrayResponse = "[ ]";
         private const string ErrorMessageResponse = "Error Message";
 
-        public FinancialModelingPrepHttpClient(HttpClient client, FinancialModelingPrepOptions options, IRequestRateLimiter rateLimiter)
+        public FinancialModelingPrepHttpClient(HttpClient client, FinancialModelingPrepOptions options,
+                                               IRequestRateLimiter rateLimiter,
+                                               ILogger<FinancialModelingPrepHttpClient> logger)
         {
             this.client = client ?? throw new ArgumentNullException(nameof(client));
             this.options = options ?? throw new ArgumentNullException(nameof(options));
             this.rateLimiter = rateLimiter ?? throw new ArgumentNullException(nameof(rateLimiter));
+            this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
             this.jsonSerializerOptions = new JsonSerializerOptions(JsonSerializerDefaults.Web);
 
             if (string.IsNullOrWhiteSpace(this.options.ApiKey))
@@ -35,10 +40,15 @@ public async Task<ApiResponse<string>> GetStringAsync(string urlPattern, NameVal
         {
             try
             {
-                await rateLimiter.ThrottleAsync();
+                var (wasThrottled, totalDelay) = await rateLimiter.ThrottleAsync();
 
                 var response = await CallApiAsync(urlPattern, pathParams, queryString);
 
+                if (wasThrottled)
+                {
+                    logger.LogDebug("FMP API Call was throttled by {throttle} ms", totalDelay.TotalMilliseconds);
+                }
+
                 if (response.HasError)
                 {
                     return ApiResponse.FromError<string>(response.Error);

FinancialModelingPrepApi/Core/Http/RequestRateLimiter.cs

@@ -9,22 +9,38 @@ namespace MatthiWare.FinancialModelingPrep.Core.Http
     public class RequestRateLimiter : IRequestRateLimiter
     {
         private readonly SemaphoreSlim threadsLimiter;
-        private readonly RollingWindowThrottler rollingWindowThrottler;
+        private readonly RollingWindowThrottler maxApiCallsPerMinuteThrottler;
+        private readonly RollingWindowThrottler maxRequestsPerSecondThrottler;
 
         public RequestRateLimiter(FinancialModelingPrepOptions options)
         {
             this.threadsLimiter = new SemaphoreSlim(options.MaxRequestPerSecond, options.MaxRequestPerSecond);
-            this.rollingWindowThrottler = new RollingWindowThrottler(options.MaxAPICallsPerMinute, TimeSpan.FromMinutes(1));
+            this.maxApiCallsPerMinuteThrottler = new RollingWindowThrottler(options.MaxAPICallsPerMinute, TimeSpan.FromMinutes(1));
+            this.maxRequestsPerSecondThrottler = new RollingWindowThrottler(options.MaxRequestPerSecond, TimeSpan.FromSeconds(1));
         }
 
-        public async Task ThrottleAsync()
-        { 
+        public async Task<(bool wasThrottled, TimeSpan totalDelay)> ThrottleAsync()
+        {
+            var totalDelay = TimeSpan.Zero;
+            var wasThrottled = false;
+
             await threadsLimiter.WaitAsync();
 
-            if (rollingWindowThrottler.ShouldThrottle(out var waitTime))
+            while (maxRequestsPerSecondThrottler.ShouldThrottle(out var waitTime))
             {
+                wasThrottled = true;
+                totalDelay = totalDelay.Add(TimeSpan.FromMilliseconds(waitTime));
+            }
+
+            while (maxApiCallsPerMinuteThrottler.ShouldThrottle(out var waitTime))
+            {
+                wasThrottled = true;
+                totalDelay = totalDelay.Add(TimeSpan.FromMilliseconds(waitTime));
+
                 await Task.Delay((int)waitTime);
             }
+
+            return (wasThrottled, totalDelay);
         }
 
         public void ReleaseThrottle() => threadsLimiter.Release();