circuit-breaker | https : //github.com/liaokailin/circuit-breaker

This is not currently supported by the Vert.x Circuit Breaker API. There is an open issue about it here. There's also a PR that attempts to fix it, but it has been sitting around for a year now. Not sure why it never got reviewed.

First, as you may know, there is no official docker image of Azcopy available. The github issue mentions it.

And yes, you can use azure function to do it(about ADF, not sure, but asked some guys, they say it's not easy to do that), but it may a little difficult.

The easier solution is to use azure web job and azcopy together. Just specify the webjob as schedule when creating it in azure portal. Azure webjob supports many file types like .ps1(powershell), .cmd, .py etc. So it's very easy to use one of your favorites to create it.

Here, I will create a .ps1(powershell) file, then upload it to azure webjob to execute the sync job on scheduled time.

Step 1: create a .ps1 file. The name of the file must be run.ps1. Then use the code below in the run.ps1 file(please use your own source storage and destination storage in the code):

I can't tell for sure from your question, but if what you're trying to do is to just keep track of how many requests are in progress and then do something in particular if that number exceeds a particular value, then you can use this middleware:

When you define a Circuit Breaker policy then you can define what sort of exception(s) should be considered by the CB implementation. In other words you can list those exceptions that should be treated as failed execution and should be counted into the successive failure count.

You can define the list of exceptions with the combination of Handle and Or method calls.

Let's scrutinize this concept via a simple example:

You ran into this issue, which was the result of us changing some APIs inside the CircuitBreaker as part of Akka.NET v1.4.11: https://github.com/akkadotnet/Akka.Persistence.SqlServer/issues/177

We just pushed Akka.Persistence.SqlServer 1.4.11 a couple of minutes ago: https://github.com/akkadotnet/Akka.Persistence.SqlServer/releases/tag/1.4.11 - upgrading to this version should resolve your issue.

two things here, shard allocation exception and circuit breaker exception(nested exception as it looks).

Please use the below command in your cluster to re-trigger the allocation as previous all retry was failed and the same is suggested in your exception message if you carefully notice. more info on below command is on this related Github issue comment.

curl -XPOST ':9200/_cluster/reroute?retry_failed

If still, it doesn't work, then you have to fix the parent circuit breaker exception, you should use the http://localhost:9200/_nodes/stats API to know the exact heap of your ES nodes, and accordingly increase it.

The Bulkhead pattern is not only about isolating thread pools.

Think of Little's law: L = λ * W

Where:

L – the average number of concurrent tasks in a queuing system

λ – the average number of tasks arriving at a queuing system per unit of time

W – the average service time a tasks spends in a queuing system

The Bulkhead pattern is more about controlling L in order to prevent resource exhaustion. This can be done by using:

• bounded queues + thread pools
• semaphores

Even non-blocking applications require resources per concurrent task which you might want to restrict. Semaphores could help to restrict the number of concurrent tasks.

The RateLimiter pattern is about controlling λ and the TimeLimiter about controlling the maximum time a tasks is allowed to spend.

An adaptive Bulkhead can even replace RateLimiters. Have a look at this awesome talk "Stop Rate Limiting! Capacity Management Done Right" by Jon Moore"

We are currently developing an AdaptiveBulkhead in Resilience4j which adapts the concurrency limit of tasks dynamically. The implementation is comparable to TCP Congestion Control algorithms which are using an additive increase/multiplicative decrease (AIMD) scheme to dynamically adapt a congestion window. But the AdaptiveBulkhead is of course protocol-agnostic.

Finally having some time to go further this issue. I uninstall the two pg modules in my fibserver application and install pg again provides me a new version of npm pg module (8.3.3) without having the native part which I probably installed by mistake. Single javascript pg library does the job.

An AWS lambda function is a stateless function, you can find more info here: https://blog.checkpoint.com/2020/03/18/aws-lambda-stateless-ephemeral/, so the information about variables, objects etc is lost after the function run and starts fresh with the next start. To implement a CB in a stateless env you have to store the state of the function call in an external database/cache etc (for aws it may be dynamoDb table, Elasticache redis, SNS queue etc). So it's possible to do it, but it has a bit of a twist.