I'im using the latest release 2.2 and .Net 4.7.2.

Is there a extension method library to add as using?

It appears to me that RateLimiter runs the tasks in sequence. This can make the application very slow.

[Test]
public void RateLimiter()
{
    TimeLimiter timeconstraint = TimeLimiter.GetFromMaxCountByInterval(3, TimeSpan.FromSeconds(1));

    var tasks = new List<Task>();

    for (int i = 0; i < 15; i++)
    {
        tasks.Add(timeconstraint.Perform(ConsoleItAsync));
    }

    Task.WaitAll(tasks.ToArray());
}

private static async Task ConsoleItAsync()
{
    await Task.Delay(800);

    var id = Thread.CurrentThread.ManagedThreadId;

    Trace.WriteLine($"{id}: {DateTime.Now:MM/dd/yyy HH:mm:ss.fff}");
}

Here I'm limiting to 3 executions per second. But because ConsoleItAsync is so slow I get fewer than 3 executions per second:

4: 10.30.2017 13:26:09.392
4: 10.30.2017 13:26:10.203
4: 10.30.2017 13:26:11.012

I think it would be better to start three tasks in parallel and when the first tasks finishes check if there is room to start another task (e.g. maxCount and timespan allow it). Otherwise Task.Delay it.

Or maybe make it more explicit in the docs that the execution will be sequentially. Because I think that people expect concurrency when they start multiple tasks via Perform.

Hello! For some time I have problems with using RateLimiter. When my program starts up, everything works fine, but after a while the RateLimiter stops working. The code in the debugger stops at the line
await _Semaphore.WaitAsync(cancellationToken); of the method.

        public async Task<IDisposable> WaitForReadiness(CancellationToken cancellationToken)
        {
            await _Semaphore.WaitAsync(cancellationToken);
            var count = 0;
            var now = _Time.GetNow();
            var target = now - _TimeSpan;
            LinkedListNode<DateTime> element = _TimeStamps.First, last = null;
            while ((element != null) && (element.Value > target))
            {
                last = element;
                element = element.Next;
                count++;
            }

            if (count < _Count)
                return new DisposeAction(OnEnded);

            Debug.Assert(element == null);
            Debug.Assert(last != null);
            var timeToWait = last.Value.Add(_TimeSpan) - now;
            try
            {
                await _Time.GetDelay(timeToWait, cancellationToken);
            }
            catch (Exception)
            {
                _Semaphore.Release();
                throw;
            }

            return new DisposeAction(OnEnded);
        }

Further, the debugger does not work, although at startup everything is fine.

I am trying to use this library, but I have multiple servers that make the calls. Any ideas about how to handle a distributed situation ?

Is it possible to check that TimeLimiter instance is available (await will return immediately) without actually awaiting it?

Use case: non-blocking rate limiting. A method is being called in a loop and if execution is attempted outside of allowed time constrains, method should just return immediately without blocking the caller.

TimeLimiter.GetAwaiter().IsCompleted is programmed to always return false, so is not an option.

Upgrading from 1.1.1 to 2.1.0 it failed to compile because perform was not found

I simply changed this to enqueue. Yet to test, but couldn't find any documentation that identified the required change when you upgraded.

Hiya,

I have a polly policy declared for my httpclient, I could do with a sample on how to get both polly and RateLimiter to play nice with eachother.

services.AddHttpClient<MyHttpClient>()
                .SetHandlerLifetime(TimeSpan.FromMinutes(5))
                .AddPolicyHandler((serviceProvider, _) => 
                    HttpPolicyExtensions.HandleTransientHttpError()
                        .WaitAndRetryAsync(Backoff.DecorrelatedJitterBackoffV2(TimeSpan.FromSeconds(1), 5),
                            (outcome, delay, i, _) =>
                            {
                                var logger = serviceProvider.GetService<ILogger<MyHttpClient>>();
                                if (logger != null)
                                {
                                    if (outcome.Exception != null)
                                    {
                                        logger.LogError(outcome.Exception, "Delaying {Delay}, then making retry {Retry}. Result: {Result}", delay, i, outcome.Result);
                                    }
                                    else
                                    {
                                        logger.LogWarning("Delaying {Delay}, then making retry {Retry}. Result: {Result}", delay, i, outcome.Result);
                                    }
                                }
                            })
                );

If I call TimeLimiter from azure function it will lockup function. I might not understand things correctly but here is the (not quite) sample code:

 [FunctionName(nameof(ResolveChildren))]
        public async Task<ActivityProfile[]> ResolveChildren([ActivityTrigger] DurableActivityContext context, ILogger log)
        {
            var input = context.GetInput<GraphInput>();
            
            ActivityProfile[] graph = await Engine.GenerateFlatGraph(input.ServiceId, input.CorellationId, input.Name, input.Factory);
            
            return graph.ToArray();
        }

engine GenerateFlatGraph calls some to some resource:

 public async Task<ActivityProfile[]> GenerateFlatGraph(string serviceId, string pipelineRunId, string pipelineName, string factoryName)
        {
            var graph = new List<ActivityProfile>();

            var result = await monitor.PipelineActivityStateAsync(serviceId, pipelineRunId, pipelineName, factoryName);

PipelineActivityStateAsync is where the limiter is being called from:

private static readonly TimeLimiter CallsPerMinuteLimiter = TimeLimiter.GetFromMaxCountByInterval(MaxCallsPerMinute, TimeSpan.FromSeconds(30));

        public ADFManagmentClientResourceAccess()
        {
            this.client = new AutoAuthenticatingDataFactoryManagementClient();

     
        }


        public async Task<ActivityProfile[]> PipelineActivityStateAsync
            (string serviceId, string pipelineId, string pipelineName, string factoryName)
        {
            await CallsPerMinuteLimiter;
            other code....

Function host times out the function because it never returns (it works without awaiting CallsPerMinuteLimiter). I will try to put reduced sample together as soon as I can to see if I can reproduce it.

This is quite an unusual scenario so this may not be the best way to resolve it, but it was one of my first ideas so I thought it was worth raising.

Scenario: We're working with an API that allows us to make 60 requests over a 60 second period. Additionally, the API returns to us (via an HTTP header) how many requests we have left, although it does not inform us when the number will be increasing. That's nice and straightforward so far. Where it gets interesting is that for the first 30 minutes of a new authorisation (new customer being onboarded) there are no limits. During this period, the HTTP header will always return 60.

Problem: We don't know at the time of making the first request (without some serious re-engineering) whether the connection is within this 30 minute window or not

Proposed Solution: If there was a method that would enable us to Pop the oldest item off the TimeStamps collection then when we got the response back, we could look at our remaining requests and if it's 60 then we could then tell the TimeLimiter to not remember that value (so it won't enforce a delay later on)

If you're happy with this kind of method being added then I'm happy to work on the implementation

The example does not fit well with the actual API calling. In the scenario where API limits 5 calls per second but itself responds back in 3-4 seconds the example code just performs one call per second since its waiting for previous call to finish. How can I remedy it.

Example code

`

        //Create Time constraint: max five times by second
        var timeconstraint = TimeLimiter.GetFromMaxCountByInterval(5, TimeSpan.FromSeconds(1));
        //Use it
        for (int i = 0; i < 1000; i++)
        {
            await timeconstraint.Perform(ConsoleIt);
        }

      
    private async Task ConsoleIt()
    {
        Console.WriteLine(string.Format("{0:MM/dd/yyy HH:mm:ss.fff}", DateTime.Now));
        await Task.Delay(3000); //simulate api call made and waiting for response. 
    }`

Hi!

At the begining I would like you for great stuff ;)

I've found a bug when using ComposedAwaitableConstraint with Cancellation token.

My use case:

• limiting api request
• call api paraller in tasks
• one of batch requests return session expired
• canel other request
• login
• repeate

Simplified example:

        private static async Task MainAsync()
        {
            var limiter = TimeLimiter.Compose(
                new CountByIntervalAwaitableConstraint(1, TimeSpan.FromSeconds(1)),
                new CountByIntervalAwaitableConstraint(1000, TimeSpan.FromHours(1))
            );

            Func<int, CancellationToken, Task> f = async (i, token) =>
            {
                await limiter.Enqueue(async () =>
                {
                    await Task.Delay(i * 100);
                    Console.WriteLine(i);
                }, token);
            };

            while (true)
            {
                var cts = new CancellationTokenSource(500);
                var combined = Task.WhenAll(Enumerable.Range(0, 10).Select(i => f(i, cts.Token)));

                try
                {
                    await combined;
                }

                catch
                {
                    ;
                }
            }
        }

Problem is here:

        public async Task<IDisposable> WaitForReadiness(CancellationToken cancellationToken)
        {
            await _Semaphore.WaitAsync(cancellationToken);
            IDisposable[] disposables;
            try 
            {
                disposables = await Task.WhenAll(_AwaitableConstraint1.WaitForReadiness(cancellationToken), _AwaitableConstraint2.WaitForReadiness(cancellationToken));
            }
            catch (Exception) 
            {
                _Semaphore.Release();
                throw;
            } 
            return new DisposeAction(() => 
            {
                foreach (var disposable in disposables)
                {
                    disposable.Dispose();
                }
                _Semaphore.Release();
            });
        }

_AwaitableConstraint2 (for hour) return:

return new DisposeAction(OnEnded);

_AwaitableConstraint1 (for second) throw TaskCancelled exception

Result is that OnEnded wont be never called and _Semaphores wont be released.

I can create new limiter after cancellation but maybe expose method like. TryRelease() on IAwaitableConstraint and call it on exception woluld be better option?

Best regards,
Mateusz

I'm getting issue while processing 150 requests.
service call failure --->
System.Threading.Tasks.TaskCanceledException: A task was canceled.
at RateLimiter.CountByIntervalAwaitableConstraint.WaitForReadiness(CancellationToken cancellationToken)
at RateLimiter.TimeLimiter.Enqueue[T](Func1 perform, CancellationToken cancellationToken) at Microsoft.Extensions.Http.Logging.LoggingHttpMessageHandler.SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) at Microsoft.Extensions.Http.Logging.LoggingScopeHttpMessageHandler.SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) at System.Net.Http.HttpClient.FinishSendAsyncBuffered(Task1 sendTask, HttpRequestMessage request, CancellationTokenSource cts, Boolean disposeCts) ...

may it's for timeout or something..
What's the request queue limit of the RateLimit?

Hi,

I'm trying to consume an API that iterates a folder and file structure and that has a limit of 2000 calls per 600 seconds.

I'm trying to come up with the best approach so that after the 600 seconds I am as close to using all 2000 calls possible without exhausting all the calls in the first 100 seconds and letting the user wait 500 seconds for the next update.

var constraint = new CountByIntervalAwaitableConstraint(4, TimeSpan.FromSeconds(1));
var constraint2 = new CountByIntervalAwaitableConstraint(1950, TimeSpan.FromSeconds(600));
limiter = TimeLimiter.Compose(constraint, constraint2);

I've gone with this to start with, but after the 600 seconds were up I still had anywhere between 50 to 600 requests remaining meaning I was leaving performance on the table.

To note is that the API also returns how many requests I have left and how long until the next reset period if I can use those values somehow as well.

When my service is left to iterate a folder structure on it's own it's more like 50 requets remaining at the end, however if the time period included a time when the user was left to select some options before clicking start then it can be more like 600.

Basically I want it to start off with about 3 requests per second, then if for some reason it isn't going to get close to 0 calls left at the end have the ability to speed up and use all the available performance.

Can I reassign to the private field? Is it thread safe to do so? Could after every 100 calls used re-evaluate the remaining performance and regenerate the limiter?
e.g.

var timeLeft = 200; //seconds
var callsLeft = 1200; //api calls

var callsPerSecond = callsLeft/timeLeft;
var constraint1 = new CountByIntervalAwaitableConstraint(callsPerSecond, TimeSpan.FromSeconds(1));
var constraint2 = new CountByIntervalAwaitableConstraint(callsLeft , TimeSpan.FromSeconds(timeLeft));
limiter = TimeLimiter.Compose(constraint1, constraint2);

Hi,

Looking in TimeSystem.cs in ITime.GetNow at line 22 it's using DateTime.Now, but if the code is running in an environment where the clocks change from DST to non-DST then DateTime.Now will suddenly return 1 hour before - and vice versa if the clocks go forward.

So I think (and please do just say if I'm misreading the code!) that if a longer running delay is active at the point when the clocks change, that the limiter might return early, OR very very late.

Perhaps a straight switch to DateTime.UtcNow would resolve this?

Thanks for this project.

I was just wondering if they is a way to hook into events for when the rate limiting starts and stops? What I would like to be able to do in my application is log when the code has been paused due to ratelimiting kicking in and then log when the code has resumed.

The basic usage example no longer works ... on the line:
await timeConstraint;
VS shows an error: 'TimeLimiter' does not contain a definition for 'GetAwaiter' and no accessible extension method 'GetAwaiter' accepting a first argument of type 'TimeLimiter' could be found.

See https://stackoverflow.com/questions/67577658/how-can-i-use-ratelimiters-httpclient-delegatinghandler-with-dependency-injecti

Issue:

[2021-05-17T21:58:00.116Z] Microsoft.Extensions.Http: The 'InnerHandler' property must be null. 'DelegatingHandler' instances provided to 'HttpMessageHandlerBuilder' must not be reused or cached.
[2021-05-17T21:58:00.117Z] Handler: 'ComposableAsync.DispatcherDelegatingHandler'.
[2021-05-17T21:58:00.122Z] An unhandled host error has occurred.

I have list of items that I want to loop through and call the async Task below, passing an item and adding the Latitude and Longitude values to the item and returning it:

public async Task<Item> GetLatitudeLongitude(Item searchItem)
{
            Uri URL = new Uri(Uri.EscapeUriString("https://www.example.com/api"));

            HttpResponseMessage response = await Client.GetAsync(URL);

            if(response.StatusCode == HttpStatusCode.OK)
            {
                string json = await response.Content.ReadAsStringAsync();

                List<Coordinates> values = JsonConvert.DeserializeObject<List<Coordinates>>(json);

                if (values.Count() > 0)
                {
                    searchItem.Latitude = values.FirstOrDefault().Latitude;
                    searchItem.Longitude = values.FirstOrDefault().Longitude;
                }

            }
return searchItem;
}

How would I call this async Task with RateLimiter? The result I'm trying to achieve is that the calls to that Task are rate limited so that I can stay below the request per minute limit of the www.example.com api.

Thank you in advance for your help.

@David-Desmaisons @firenero

How feasible would it be to write a limiter for this library that would reject new requests until the resource becomes again available?

If it's straightforward, I'd be willing to give it a try. However, I wouldn't want to embark on that if it doesn't sound like a good application of this library.

What are your thoughts? What advice would you give or any theories for how one my approach a rejection limiter?

Was trying RateLimiter, but can't get it to work like showed in the Readme / Documentation.

Error CS1061 'TimeLimiter' does not contain a definition for 'GetAwaiter' and no accessible extension method 'GetAwaiter' accepting a first argument of type 'TimeLimiter' could be found (are you missing a using directive or an assembly reference?)

Tried with .NET Framework 4.7.2 and .NET 5.

Is the code changed lately?
 

Code:

using RateLimiter;
using System;
using System.Threading.Tasks;

namespace RateLimiterTest
{
    class Program
    {
        private static readonly TimeLimiter TimeLimiterTest = TimeLimiter.GetFromMaxCountByInterval(20, TimeSpan.FromMinutes(1));

        static async Task Main(string[] args)
        {
            Console.WriteLine("Hello World!");

            await TimeLimiterTest;

            Console.WriteLine("Finished!");
        }
    }
}

Also it would be nice to use an interval of 5 seconds so you can better see the time differences.

Hi

I've notice that Your mechanism is counting time of end of task. This is done in https://github.com/David-Desmaisons/RateLimiter/blob/master/RateLimiter/CountByIntervalAwaitableConstraint.cs#L107

Would you like the ability to optionaly setup counting time on start task?

Example: I have api which consumes 1 request/ 2 seconds. One request takes 5s. Finally I have only 1 request / 5 second, which is slow performance. I wish to send 1r/2s (I don't care of time that request takes)

I am counting on your answer.
Greetings

RateLimiter requires to package the rate limited code into a method. This can get awkward very quickly if the code that needs to be rate limited contains other code that needs to be rate limited, and so following the flow of the program becomes a bit difficult.
As a result, I almost always end up defining and using the following Wait extension methods, to make RateLimiter look more like other synchronization classes (SemaphoreSlim, Monitor, WaitHandle) and avoid refactoring the code into a chain of methods.

public static class TimeLimiterExtensions
{
	private static readonly Action doNothing = delegate { };

	public static async Task Wait(this TimeLimiter timeLimiter)
	{
		await timeLimiter.Perform(doNothing);
	}

	public static async Task Wait(this TimeLimiter timeLimiter, CancellationToken cancellationToken)
	{
		await timeLimiter.Perform(doNothing, cancellationToken);
	}
}

I thought this would be beneficial to other users, and was wondering if you would incorporate something like this in the project.
I'm unsure about the contribution policy, so I'm asking here instead of just creating a pull request.

When attempting to use the library in a .NET Standard 2.1 or .NET Core 3.1 project that uses IAsyncDisposable (for example, asynchronous disposal of a stream), the project fails to build with a CS0518 error.

  Program.cs(21, 17): [CS0518] Predefined type 'System.IAsyncDisposable' is not defined or imported

namespace Scratchpad
{
    public class Program
    {
        public static async Task Main(string[] args)
        {
            var rateLimiter = TimeLimiter.GetFromMaxCountByInterval(1, TimeSpan.FromSeconds(1));

            for (var i = 0; i < 10; ++i)
            {
                await using var ms = new MemoryStream();

                await rateLimiter;
                Console.WriteLine(DateTime.UtcNow);
            }
        }
    }
}

Adding .NET Standard 2.1 as an additional target for the library should correct the issue, allowing it to natively understand duck-typed IAsyncDisposable types.

Hi Can someone share me how to use RateLimiter with synchronous method?

In the synchronous method I am using the way like that:

Logfile.Info("Start RateLimit");
Task.Run(async () =>
{
await timeConstraint;
}).Wait();
Logfile.Info("End RateLimit");

But it get deadlocked when calling this synchronous method from multiple thread

Thank you

@David-Desmaisons
Sorry if it's a stupid question, but I'm new to this..

After I installed the package, using nuget in visual studio community, I'm getting this error:

package 'RateLimit 1.1.0' was restored using .NetFramework version=v4.6.1 instead of the project target framework .NetCoreApp version=v2.0 this package may not be fully compatible with your project

I'm using .net core project.
does that mean that I can't use the package in .net core?