Add thread bases and time based rate limiter

- Max amount of requests per second
- Max amount of API calls per minute

Author: Matthiee

FinancialModelingPrepApi/Abstractions/Http/IRequestRateLimiter.cs

@@ -0,0 +1,10 @@
+using System.Threading.Tasks;
+
+namespace MatthiWare.FinancialModelingPrep.Abstractions.Http
+{
+    public interface IRequestRateLimiter
+    {
+        public Task ThrottleAsync();
+        public void ReleaseThrottle();
+    }
+}

FinancialModelingPrepApi/Core/Http/FinancialModelingPrepHttpClient.cs

@@ -1,10 +1,10 @@
-using MatthiWare.FinancialModelingPrep.Model;
+using MatthiWare.FinancialModelingPrep.Abstractions.Http;
+using MatthiWare.FinancialModelingPrep.Model;
 using MatthiWare.FinancialModelingPrep.Model.Error;
 using System;
 using System.Collections.Specialized;
 using System.Net.Http;
 using System.Text.Json;
-using System.Threading;
 using System.Threading.Tasks;
 
 namespace MatthiWare.FinancialModelingPrep.Core.Http
@@ -13,17 +13,17 @@ public class FinancialModelingPrepHttpClient
     {
         private readonly HttpClient client;
         private readonly FinancialModelingPrepOptions options;
+        private readonly IRequestRateLimiter rateLimiter;
         private readonly JsonSerializerOptions jsonSerializerOptions;
         private const string EmptyArrayResponse = "[ ]";
         private const string ErrorMessageResponse = "Error Message";
-        private readonly SemaphoreSlim throttler;
 
-        public FinancialModelingPrepHttpClient(HttpClient client, FinancialModelingPrepOptions options)
+        public FinancialModelingPrepHttpClient(HttpClient client, FinancialModelingPrepOptions options, IRequestRateLimiter rateLimiter)
         {
             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.jsonSerializerOptions = new JsonSerializerOptions(JsonSerializerDefaults.Web);
-            this.throttler = new SemaphoreSlim(options.MaxRequestLimit);
 
             if (string.IsNullOrWhiteSpace(this.options.ApiKey))
             {
@@ -33,30 +33,35 @@ public FinancialModelingPrepHttpClient(HttpClient client, FinancialModelingPrepO
 
         public async Task<ApiResponse<string>> GetStringAsync(string urlPattern, NameValueCollection pathParams, QueryStringBuilder queryString)
         {
-            await throttler.WaitAsync();
+            try
+            {
+                await rateLimiter.ThrottleAsync();
 
-            var response = await CallApiAsync(urlPattern, pathParams, queryString);
+                var response = await CallApiAsync(urlPattern, pathParams, queryString);
 
-            throttler.Release();
+                if (response.HasError)
+                {
+                    return ApiResponse.FromError<string>(response.Error);
+                }
 
-            if (response.HasError)
-            {
-                return ApiResponse.FromError<string>(response.Error);
-            }
+                if (response.Data.Contains(ErrorMessageResponse))
+                {
+                    var errorData = JsonSerializer.Deserialize<ErrorResponse>(response.Data);
 
-            if (response.Data.Contains(ErrorMessageResponse))
-            {
-                var errorData = JsonSerializer.Deserialize<ErrorResponse>(response.Data);
+                    return ApiResponse.FromError<string>(errorData.ErrorMessage);
+                }
 
-                return ApiResponse.FromError<string>(errorData.ErrorMessage);
-            }
+                if (response.Data.Equals(EmptyArrayResponse, StringComparison.OrdinalIgnoreCase))
+                {
+                    return ApiResponse.FromError<string>("Invalid parameters");
+                }
 
-            if (response.Data.Equals(EmptyArrayResponse, StringComparison.OrdinalIgnoreCase))
+                return ApiResponse.FromSucces(response.Data);
+            }
+            finally
             {
-                return ApiResponse.FromError<string>("Invalid parameters");
+                rateLimiter.ReleaseThrottle();
             }
-
-            return ApiResponse.FromSucces(response.Data);
         }
 
         public async Task<ApiResponse<T>> GetJsonAsync<T>(string urlPattern, NameValueCollection pathParams, QueryStringBuilder queryString)

FinancialModelingPrepApi/Core/Http/RequestRateLimiter.cs

@@ -0,0 +1,32 @@
+using Bert.RateLimiters;
+using MatthiWare.FinancialModelingPrep.Abstractions.Http;
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace MatthiWare.FinancialModelingPrep.Core.Http
+{
+    public class RequestRateLimiter : IRequestRateLimiter
+    {
+        private readonly SemaphoreSlim threadsLimiter;
+        private readonly RollingWindowThrottler rollingWindowThrottler;
+
+        public RequestRateLimiter(FinancialModelingPrepOptions options)
+        {
+            this.threadsLimiter = new SemaphoreSlim(options.MaxRequestPerSecond, options.MaxRequestPerSecond);
+            this.rollingWindowThrottler = new RollingWindowThrottler(options.MaxAPICallsPerMinute, TimeSpan.FromMinutes(1));
+        }
+
+        public async Task ThrottleAsync()
+        { 
+            await threadsLimiter.WaitAsync();
+
+            if (rollingWindowThrottler.ShouldThrottle(out var waitTime))
+            {
+                await Task.Delay((int)waitTime);
+            }
+        }
+
+        public void ReleaseThrottle() => threadsLimiter.Release();
+    }
+}

FinancialModelingPrepApi/DependencyInjectionExtensions.cs

@@ -1,6 +1,7 @@
 using MatthiWare.FinancialModelingPrep.Abstractions.AdvancedData;
 using MatthiWare.FinancialModelingPrep.Abstractions.Calendars;
 using MatthiWare.FinancialModelingPrep.Abstractions.CompanyValuation;
+using MatthiWare.FinancialModelingPrep.Abstractions.Http;
 using MatthiWare.FinancialModelingPrep.Abstractions.InstitutionalFund;
 using MatthiWare.FinancialModelingPrep.Abstractions.MarketIndexes;
 using MatthiWare.FinancialModelingPrep.Abstractions.StockTimeSeries;
@@ -36,6 +37,7 @@ public static void AddFinancialModelingPrepApiClient(this IServiceCollection ser
                 => client.BaseAddress = new Uri("https://financialmodelingprep.com/api/"));
 
             services.TryAddSingleton<IFinancialModelingPrepApiClient, FinancialModelingPrepApiClient>();
+            services.TryAddSingleton<IRequestRateLimiter, RequestRateLimiter>();
             services.TryAddTransient<ICompanyValuationProvider, CompanyValuationProvider>();
             services.TryAddTransient<IMarketIndexesProvider, MarketIndexesProvider>();
             services.TryAddTransient<IAdvancedDataProvider, AdvancedDataProvider>();

FinancialModelingPrepApi/FinancialModelingPrepApi.csproj

@@ -29,6 +29,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="Bert.RateLimiters" Version="1.0.15" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="5.0.0" />
     <PackageReference Include="Microsoft.Extensions.Http" Version="5.0.0" />
     <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="5.0.0" />

FinancialModelingPrepApi/FinancialModelingPrepOptions.cs

@@ -17,6 +17,14 @@ public class FinancialModelingPrepOptions
         /// By default the max allowed is 10. If you have a different rate limit you can configure it here.
         /// See Rate Limitation #15 https://financialmodelingprep.com/developer/docs/terms-of-service
         /// </summary>
-        public int MaxRequestLimit { get; set; } = 10;
+        public int MaxRequestPerSecond { get; set; } = 10;
+
+        /// <summary>
+        /// Gets or sets the maximum allowed API Calls per second.
+        /// You can find the defaults on the pricing documentation. 
+        /// By default we use the 300 "starter" limit.
+        /// https://financialmodelingprep.com/developer/docs/pricing
+        /// </summary>
+        public int MaxAPICallsPerMinute { get; set; } = 300;
     }
 }