Join GitHub today
GitHub is home to over 28 million developers working together to host and review code, manage projects, and build software together.Sign up
OPTION/PROPOSAL: Distributed Circuit Breaker #287
Detailed architecture proposal for a Distributed Circuit Breaker. TL;DR summary will also follow.
Background: What is a Distributed Circuit Breaker?
In a distributed system with multiple instances of an application or service A, there could be an advantage in sharing information about circuit state between instances of upstream system A which all call downstream system B.
The intention is that if the circuit-breaker in node A1 governing calls to system B detects "system B is down" (or at least, breaks), that knowledge could be shared to nodes A2, A3 etc, such that they could also break their circuits governing calls to B if deemed appropriate.
The need for quorum decisions
The assumption of a simple implementation like this is that if the circuit in A1 governing calls to B breaks, this "means" system B is down. But that is only one of three broad causes for the circuit in A1 governing calls to B breaking. Possibilities include:
(1) node A1 has some internal problem of its own (eg resource starvation, possibly due to unrelated causes)
In scenarios (1) and (2), if A1 wrongly tells A2, A3, A4 etc that they cannot talk to B (when in fact they can), that would entirely negate the redundancy value of having those horizontally scaled nodes A2, A3 etc ... a (self-induced) catastrophic failure.
As commented here, a quorum approach can mitigate this concern.
An extra dependency in the mix
Co-ordinating circuit state between upstream nodes A1, A2, A3 etc also introduces an extra network dependency, which may itself suffer failures or latency.
(Note: I have since discovered the Hystrix team echo these concerns.)
Why then a Distributed Circuit Breaker?
The premise is that when state co-ordination works well - and where empirically in some system, the causes of such circuits breaking are predominantly cause (3) not (1) or (2) - then a distributed circuit breaker may add value.
Without a distributed circuit, upstream nodes A1, A2, A3 etc may each have to endure a number of slow timeouts (say), before they decide to break. With a distributed circuit, knowledge of failing to reach B can be shared, so that other upstream A-nodes may elect to break earlier and fail faster.
The classic application would be in horizontally-scaled microservices systems.
Proposed architecture for DistributedCircuitBreaker
Let us use the terminology
This was referenced
Aug 2, 2017
But I would definitely like to have an opt-in transient fault handling into circuit breaker so that a transient error does not cause the circuit breaker to trip.
Although I did participate and support the quorum idea earlier, I think maintaining quorum state is a hard problem to solve and requires internal knowledge of the application and the network, therefore I would rather not implement it in Polly. Moreover, many of the Microservices platforms such as Service Fabric know how to maintain a quorum and I believe no one using Polly would want to override that feature with our implementation.
Ok, as mentioned on the Slack channel, I had deleted my post just as @rahulrai-in was replying to both @reisenberger and myself. I wasn't happy with the clarity of my my post, and now I have more time, I will now attempt to explain my position in a more structured manner:
1. Infrastructure Solutions
So, let's start by looking at resilience in general, and where Polly Circuit Breaker can fit in. In terms of my preferred cloud provider, Azure, there are multiple levels where resiliency and redundancy can be implemented. AWS and Google Cloud offer similar solutions. Third parties offer on-premise solutions.
When I plan my app deployments, I use the built-in Azure features of scale sets, fault zones, and update zones, to prevent temporary outages causing service interruptions. Take for example, a backend set
This propagates up to the other 'named service' that originally called the failed service. It's own Circuit Breaker Policies determine that its dependency 'named service' is unavailable, and determines if a feature should be disabled (e.g. video processing, or new user registrations as email confirmations are not available), and this is reflected in the backend.
In addition to the Load Balancer option, Azure offers Application Gateway (routing or requests to different 'named services' based on url rules, health etc), and Traffic Manager (DNS based redirection of traffic based on policy rules, that allow failover to a different data center or region, and can also handle services which are not hosted on Azure).
I recommend reading Using load-balancing services in Azure
Again, each of these can be configured to probe Circuit Breaker State.
I have worked with Akka.Net, and it has its own official Akka.Net Circuit Breaker that takes advantage of Akka specific features for state persistence and rehydration; it is far better to not attempt to reinvent the wheel in these circumstances.
2. Quorum Logic Is Hard
These services mentioned above in point 1 are aware of nodes, have advanced policy configuration, and IMHO obviate the need for Polly Circuit Breaker to implement it's own quorum logic. We would never be able to implement a solution of sufficient quality. Here is an interesting read if you wish to explore that avenue:
3. My Personal Recommendations For State
There is a need for shared / distributed Circuit Breaker State. I would break this down into two options:
A simple Redis cluster (2 nodes), optionally acting as a pass through cache will be sufficient for medium availability, and meet 80%+ of use cases, as a guestimate. That gives you extremely fast response times (especially if deployed to the same virtual network as your core app services, if you are using a Cloud provider), and auto failover.
Importantly, it is possible to combine Redis with local, in memory caches of data, which are then synchronised with Redis, and provide resiliency to storage of state data. Here is one library that can achieve this, there are others:
CacheManager- Open Source, can use a variety of backends, but Redis is the more feature rich.
I'ts worth noting a feature CacheManager offers which is highly relevant:
Note that you can still also use this approach with Redis distributed cache as the source of truth, which is preferable for allowing new nodes to be brought online and query Redis for their initial state.
The Redis based synchronisation of local in-memory caches would be used to prevent the nodes of a 'named service' repeatedly calling a service that was failing under high load and causing it to fail.
If Redis goes down / is not contactable, the nodes continue to use their local cached data, which would effectively mean the centralised control is automatically delegated to the distributed services, allowing them to act independently. When Redis is available again, they can be synchronised. This avoids creating a single point of failure.
Individually, they are also still managed by the Load Balancer determining their health and Circuit Breaker status. And the Traffic Manager above them, co-ordinates failover and optimised performance. Essentially you have a self-healing infrastructure.
A 'managed microservice' - think Azure Functions or AWS Lambda, which can then call whatever data store you want. As any session state I have is maintained in my client for many reasons including scale, I certainly don't want to corrupt that architecture by then managing a farm of Microservices that are simply there to maintain my Circuit Breaker State.
My personal preference: just build a very simple interface for any Provider to implement:
And then create an 'official' Redis Provider, and let the community create their own, for their specific scenarios.
For roll-your own approaches, the configuration of nodes, logic for any scenario specific rules that determine state (including reported failure ratios, whether a reported error on A categorically affects B, etc), can be passed into the Provider instance, but, should not be known to Polly, as they are, well, scenario specific and entirely optional. It simply should not be part of core Polly Circuit Breaker.
The only thing that Polly Circuit Breaker would know is the serviceName, its State, and its corresponding Policy.
Polly Circuit Breaker would still be highly relevant; I would look at using it to determine if a named service instance is able to connect to its database / storage / email backend, and report to Load Balancer / Traffic Manager etc that is alive and well, or failed. I would use a Circuit Breaker in my main application API to inform my UI if certain features are not available. But, it would not be the only tool used to address resilience issues; IMHO it needs to have a clearly defined role, interface, and functionality, and I feel the proposals so far are perhaps over-engineered.
Just my 2 centavos.
Thank you @mcquiggd for your comments. It looks as if elements of the proposal may have come across not as I intended; I'll aim to clarify. The comments on resilience in Azure also are great perspectives to have; thank you. There is no intention that Polly should overlap with any of that; we see the role of Polly in architectures also that Polly only provides resilience primitives.
Polly users were asking about a quite specific scenario; I'll aim to focus discussion back on that, if only to move it forward (but light shone from other angles of course always welcome!).
What problem are we trying to solve?
Polly users asked here
and I am understanding these requests to mean we are considering a scenario where multiple upstream services/apps/nodes all call a single downstream dependency.
(The downstream system may have redundancy/horiz-scaling too, but let's consider that is hidden behind load-balancing/Azure Traffic Manager/whatever, so we are addressing via a single endpoint.)
(We could also be talking about multiple dissimilar upstream systems A, B, C, D etc all calling M.)
With current Polly, each upstream node/system would have an independent circuit-breaker:
I am understanding that Polly users are asking for some way for those circuit-breakers to share state or share knowledge of each other's state, such that they would (or could choose whether to) break in common.
Why a single shared circuit state can be dangerous: the "one bad node poisons other good nodes" problem
One solution could use a single shared breaker state:
(the breakers exist as independent software elements in each upstream node/system; the solid box round them here is intended to illustrate they all consult/operate to the same shared state)
and the benefit is that if one upstream caller "knows" the downstream system M is down, the other callers immediately share that knowledge (probably failing faster than if they were fully independent):
As however noted in the original proposal and linked threads (here, here, here) and others also noted, an approach with a single shared circuit state also risks (and by definition embeds) a catastrophic failure mode.
If the reason for the circuit-of-A1-governing-M breaking is not that downstream system M is down, but instead a problem local only to A1 (eg resource starvation in A1 affecting those calls) or to the path between A1 and M, then the single shared circuit state inappropriately cuts off all the other nodes/upstream systems from communicating with M:
(M was healthy (green). Upstream A2, A3 etc were healthy (green) and had good paths (green) to M giving green local circuit statistics. Without the shared circuit state, the system would have had the redundancy benefit of A2, A3 etc still supporting healthy calls to M. However, because A1 has told the single shared circuit state to break, A2, A3 etc cannot communicate to M, and the redundancy value of A2, A3 etc is thrown away.)
This is a resilience anti-pattern: the single shared circuit state approach inappropriately promotes a localised problem to a global/more widespread one, causing a (horizontally) cascading failure.
I call this the "one bad node poisons other good nodes" problem.
Any approach taking the word of a single source as enough evidence that the downstream system is down, risks this: a failure at a single source will block all consumers.
It's rare, but it can happen. Nodes go bad. We all know the fallacies of distributed computing. The problem is not that it happens very often, but that if/when it does, the single-shared-state design (yoking upstream callers together so tightly) has such a catastrophic effect.
It's a bit like journalism: don't trust a story from only one source; corroborate it with others before acting.
(So the simplification proposed in your point 3 @mcquiggd in principle embeds this risk. That would have been the original proposal, were it not for this risk. Of course the simplification may well be the more appropriate solution, if in a given system you judge the risk to be acceptable.)
Without the single shared circuit state, we would have continued to have the redundancy benefit of the horizontal scaling:
So: Can we fashion a solution which gives the benefits of [*1] and [*3], but avoids the failure of [*2]?
'Crowd sourcing' whether to break - some simple quorum logic
The essence of the proposal is that we let users configure the number or proportion of nodes breaking, among the set, that are deemed sufficient to cause a distributed break. This creates a non-blunt instrument. Consistency of experience across callers gives enough confidence that the real-world happening is a downstream system failure, not something local to a particular caller.
Rather than seeking to impose a single shared truth model, the approach models the real-world complexity of multiple truths (that different callers might have different experiences of their call success to M). And provides a user-configurable way to negotiate that.
Nodes tell the mediator when their local circuit transitions state. And nodes can ask the mediator the state of all nodes in the set.
Based on this, the arbiter then embeds some extremely simple quorum logic (only requires addition and division):
This 'crowd sources' the wisdom of whether to distributed-break or not, in a non-blunt way.
The solution correctly negotiates the scenario which for the simpler implementation induced the anti-pattern [*2]:
But also provides the [*1] benefit - if M is down, the quorum logic soon detects this, and breaks:
Mechanisms for sharing state
The mechanisms for sharing state information between nodes are intended exactly to be existing distributed cache technologies such as Redis, NCache etc. (As you say @mcquiggd, all of these with their dual in-memory/remote-syncd caching are great fits.) It also doesn't have to involve a store: if users already have some asynchronous messaging tech in the mix - Azure Service Bus Queues, Amazon SQS, RabbitMQ, whatever - these are alternatives too.
Polly just provides a primitive
This doesn't make Polly embed any knowledge about the system being governed. As ever, Polly just provides a resilience primitive. Users model it to their own system by choosing which upstream systems to group into which distributed circuits, what quorum thresholds to configure, etc.
The preceding post aimed to clarify, to further discussion; not to assume what we should implement.
From an understanding of the behavioural characteristics of different solutions, we can then discuss the trade-offs that there are, between complexity and fidelity/behaviour.
What do others think about the "one bad node poisons other good nodes" problem?
@mcquiggd You are deeper into Azure than I: In the Azure IaaS environment, do you see upstream system behaviour as likely to be so consistent, that the risk can safely be ignored, or?
My take is that in principle the problem exists for any single-shared-circuit-state design. In practice, as an engineer designing for a particular system, it would of course be perfectly reasonable (and very often the right decision) to be making judgments like "For my installation, that is 'not going to happen'; at least, I will sacrifice that level of engineering, and take the risk".
The trouble is, as a library, we can't foresee and don't have control over the environments in which users use the feature.
Four options to move forward: (other suggestions also welcome)
(a) do nothing
Certainly valid to ask: is the feature worth it, for the amount of engineering necessary to get it right? Wouldn't fully independent upstream callers just discover a downstream failure of their own accord, in due course? Early on I was in that camp.
However, users have asked for this feature, and it can prevent each upstream caller in turn eg waiting on a timeout, to discover the same failure. So I have aimed to propose a mature/robust design that at least avoids a catastrophic failure mode.
(b) implement the simple version
Implement in Polly only the simple version that embeds the anti-pattern, but warn users clearly of that failure mode. Caveat emptor! IE that users should only use it in systems, or with a scope, where they consider that not a risk.
API: Users have to specify:
(c) the quorom-decision version
The store implementations would be not that much more complicated than (b) - it's only sticking objects in a distributed cache.
API: Users have to specify:
(d) Only adapt Polly to allow injection of new circuit-breaker implementations
Don't attempt to force a decision now between (b) and (c) for core Polly. Instead simply refactor the circuit-breaker to allow injection of a custom
Seriously impressed with your explanation - I take my hat off to you... you've brought clarity to a subject that is tough to describe.
Personally, I had seen some very specific use-cases being discussed, that I simply would not encounter.
But to answer the specific question:
Well, in the systems I typically use for my mission critical backends, you can 'planet scale' Cosmos DB as long as your budget lasts. You can autoscale your Redis cluster until your credit card melts.
If systems such as these, with millisecond failover times to geographically separate mirrors are not sufficient, a Polly circuit breaker with distributed state isn't going to add too much other than another point of failure. In the scenarios I described with Redis and a local cache, you have built-in resiliency for every node of every type of service. I handle offline capability in my client, and attempt to resolve data issues when the system is available again.
So, I might pull back from this topic, however, as I don't want to muddy the water. Each of us will have our own requirements, I would just advise that whatever solution that is settled on, is as pluggable as possible, so users can make their own choice for simple, advanced, and industrial-strength SkyNet level resiliency of their circuit breaker state. Basically, let the users decided from all the options:
So, my vote is for (d) Only adapt Polly to allow injection of new circuit-breaker implementations.
Very interested to see what others opinions are... the more eyes on this, the better...
Fantastic write up guys of all points so far. As somehow who has implemented something like this, I went down the route suggested by @mcquiggd. I implemented a decorator above Polly that used Redis caching to hold state - it isn't perfect but it's good enough for our needs.
Therefore, although I would love an out of the box solution to take the problem away, I agree that this is hard and there are so many possibilities for how to implement this so I'd rather have an extension point / interface that I can hook into instead.
Polly Contrib would be nice and, eventually perhaps, this goes down the NHibernate route of incorporating battle-tested stable contribs into polly itself but that's for something down the road.
I'd vote for (d), but a simple OOB contrib to demonstrate an example would also be helpful
Hi, I would go through this today and add my inputs.…
Sent from my Windows 10 phone From: reisenberger<mailto:email@example.com> Sent: Wednesday, 23 August 2017 7:01 AM To: App-vNext/Polly<mailto:Polly@noreply.github.com> Cc: Rahul Rai<mailto:firstname.lastname@example.org>; Mention<mailto:email@example.com> Subject: Re: [App-vNext/Polly] OPTION/PROPOSAL: Distributed Circuit Breaker (#287) I am keen on the (d) extension-point idea as a way forward for this too. @rahulrai-in<https://github.com/rahulrai-in> : would that suit your needs too? — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub<#287 (comment)>, or mute the thread<https://github.com/notifications/unsubscribe-auth/ALVfvHLTyb4-9KyCQAjROK2JkIziTYYDks5sa0GogaJpZM4Oqtop>.
referenced this issue
Sep 18, 2017
The serverless compute model makes sharing state like this for circuit breakers absolutely necessary.
Right now local-circuit breaking requires each node to learn on it's own that a given dependency is down. If your instances are long-lived with persistent in-memory state, that's OK. E.g. on the first 5 requests an instance sees failure, and then circuit breaks the dependency. Those 5 requests are essentially an learning period.
However, with serverless compute models (e.g. AWS Lambda or Azure Cloud Functions) each instance's internal memory/state is highly transitory. In the extreme, each instance only survives long enough to make a single request to the dependency, and thus no node would survive long enough to learn the dependency's condition. The system would become equivalent to one with no circuit breaking at all.
Sharing state would become necessary so that all of the nodes contribute their learnings together.
I would like to prioritize this for 2018. I'm also interested in taking the lead on this, as I've recently run across a good use case when using a Circuit Breaker in an Azure Function that could automatically scale out to multiple instances. This is where a distributed Circuit Breaker would come in as a useful way to make sure multiple instances aren't overloading a downstream service. Right now, when your Azure Function scales to 20 instances, per se, they each have their own Circuit Breaker instance. So one tripping a breaker won't cause another to stop processing.
@reisenberger had suggested calling a Distributed Circuit Breaker a Circuit Breaker as a Service, or "seabass". I like it :)
To follow up the point, well made by @heneryville - Azure Durable Functions now offer state persistence and long-running lifetimes, with triggers to rehydrate, for example to respond to external processes calling back to continue a defined workflow. Microsoft are adding multiple persistence backends for Azure Durable Functions.
They could be considered to be a lightweight alternative to Logic Apps.
Personally I use them for executing other Functions in a defined order - their state is persisted automatically.
Perhaps there are lessons we can learn from this approach.
referenced this issue
Sep 8, 2018
Is this still up for grabs? I'd love to take this up.
Little background: I work at Microsoft and we use Polly in everything we do. Personally, I have a decent foundation in distributed systems theory, and at work, I have experience with microservice based architectures. I'd need a lot of help along the way, but I'm committed to putting in the time and effort to see this through. I went through the thread, and it looks like a good place to start.
@utkarsh5k That's great to hear! It would be great to have more developer power on this.
That is: refactoring the circuit-breaker engine so that it provides a better
And simultaneously: refactoring the existing controller of the original circuit-breaker so that it could take (by injection) an
Perhaps I should take a few more days to see if I can progress that, but also look for a good place to share work out?
I am all for an extensible model for circuit breaker. There should be a single I terrace which the providers can implement. Outlook for Android…
________________________________ From: Dylan Reisenberger <firstname.lastname@example.org> Sent: Tuesday, November 13, 2018 9:13:08 AM To: App-vNext/Polly Cc: Rahul Rai; Mention Subject: Re: [App-vNext/Polly] OPTION/PROPOSAL: Distributed Circuit Breaker (#287) @utkarsh5k<https://github.com/utkarsh5k> That's great to hear! It would be great to have more developer power on this. In (scarce) spare hours in the last few weeks I coincidentally started on point (d) of this comment<#287 (comment)>, which is simpler than the original proposal<#287 (comment)>: (d) Only adapt Polly to allow injection of new circuit-breaker implementations That is: refactoring the circuit-breaker engine so that it provides a better ICircuitController seam (or similar) for the injection of custom ICircuitController (or similar) implementations. And simultaneously: refactoring the existing controller of the original circuit-breaker<https://github.com/App-vNext/Polly/wiki/Circuit-Breaker> so that it could take (by injection) an IConsecutiveCountCircuitBreakerStateStore (and refactoring the existing in-memory implementation to fulfil this). Building a distributed consecutive-count circuit-breaker would then be a matter of coding, say, a StackExchange.Redis<https://stackexchange.github.io/StackExchange.Redis/> (or similar) implementation for IConsecutiveCountCircuitBreakerStateStore. Comments welcome! Perhaps I should take a few more days to see if I can progress that, but also look for a good place to share work out? — You are receiving this because you were mentioned. Reply to this email directly, view it on GitHub<#287 (comment)>, or mute the thread<https://github.com/notifications/unsubscribe-auth/ALVfvCuU6X2gBrBSydBRlHgwKL1FqFibks5uufJ0gaJpZM4Oqtop>.