Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/rueian/context-circuit-breaker

context circuit breaker for nodejs
https://github.com/rueian/context-circuit-breaker

async-await circuit-breaker nodejs promise

Last synced: about 1 month ago
JSON representation

context circuit breaker for nodejs

Awesome Lists containing this project

README 

        
# ContextCircuitBreaker



Modified from https://github.com/yammer/circuit-breaker-js



## Usage



```js

const MongoClient = require('mongodb').MongoClient;

const breaker = new ContextCircuitBreaker({

  contextBuilder: async () => await MongoClient.connect('mongodb://localhost:27017', { reconnectTries: 1 }),

  contextCleaner: async (client) => client.close()

});



const command = async (client) => {

  return await client.db('mydb').collection('mycollection').find({a: 1}).limit(2).toArray();

};



const fallback = async () => {

  return [];

}



breaker.run(command, fallback).then((ret) => {

  console.log(ret); // []

})



breaker.destroy();

```



## API



### ContextCircuitBreaker([config])



Create a new instance of a circuit breaker. Accepts the following config options:



#### contextBuilder() -> Promise



A function build the context and return Promise.resolve(context) or Promise.reject(err).



ContextCircuitBreaker will call this function when trying to transit HALF_OPEN state and keep the context for running command



#### contextCleaner(context) -> Promise



A function clean the context and return Promise.resolve() or Promise.reject(err).



ContextCircuitBreaker will call this function when transit to OPEN state.



### nextTryTimeout() -> integer



A function return a integer as milliseconds.



ContextCircuitBreaker will call this function when failing to transit HALF_OPEN state to schedule the next try.



*Default Value:* function() { return 5000 }



#### windowDuration



Duration of statistical rolling window in milliseconds. This is how long metrics are kept for the circuit breaker to use and for publishing.



*Default Value:* 10000



#### timeoutDuration



Time in milliseconds after which a command will timeout.



*Default Value:* 300



#### errorThreshold



Error percentage at which the circuit should trip open and start short-circuiting requests to fallback logic.



*Default Value:* 50



#### volumeThreshold



Minimum number of requests in rolling window needed before tripping the circuit will occur.



For example, if the value is 20, then if only 19 requests are received in the rolling window (say 10 seconds) the circuit will not trip open even if all 19 failed.



*Default Value:* 5



### run(command, fallback)



the `command` should be: `function(context) -> Promise`



the `fallback` should be: `function(err) -> Promise`



this behavior is:



```

#run when state is CLOSE

  ✓ execute command(context)

  ✓ return Promise.resolve(command(context)) if command(context) succeeded

  ✓ return Promise.resolve(fallback(commandErr)) if command(context) returned Promise.reject(commandErr)

  ✓ return Promise.resolve(fallback(commandErr)) if command(context) throwed commandErr

  ✓ return Promise.resolve(fallback(timeoutErr)) if command(context) timeout

  ✓ return Promise.reject(commandErr) if no fallback provided and command(context) returned Promise.reject(commandErr)

  ✓ return Promise.reject(commandErr) if no fallback provided and command(context) throwed commandErr

  ✓ return Promise.reject(timeoutErr) if no fallback provided and command(context) timeout

  ✓ transit to OPEN if the failures of command(context) exceed the volumeThreshold and errorThreshold



#run when state is OPEN

  ✓ return Promise.resolve(fallback(openErr))

  ✓ return Promise.reject(openErr) if no fallback provided

```



### destroy()



Cleanup context by calling contextCleaner(context) and clear all timers and all event listeners.



## State Machine Spec



```

given OPEN state

  when receives command

    then return fallback

  when nextTry timeout reached

    then try to run contextBuilder

      given service is not connectable  

        then emit contextbuilderFailed

        then remain state OPEN

        then schedule nextTry timeout

      given service connectable

        then transit to HALF_OPEN

        then emit stateChanged with HALF_OPEN

        then emit contextbuilderSucceeded



given HALF_OPEN state

  when receives the first command

    then run command

      given the first command succeeded

        then return command result

        then transit to CLOSE

        then emit stateChanged with CLOSE

      given the first command failed

        then return fallback

        then transit to OPEN

        then emit stateChanged with OPEN

        then schedule nextTry timeout 

        then run contextBuilderCleaner

          given contextBuilderCleaner succeed

            then emit contextBuilderCleanerSucceeded

          given contextBuilderCleaner failed

            then emit contextBuilderCleanerFailed

  when receives following commands

    then all return fallback



given CLOSE state

  when receives command

    then run command

      given command succeed

        then return command result

      given command failed

        then return fallback

          given volumeThreshold not exceed

            then remain CLOSE

          given volumeThreshold exceed

            given errorThreshold not exceed

              then remain CLOSE

            given errorThreshold exceeded

              then transit to OPEN

              then emit stateChanged with OPEN

              then schedule nextTry timeout 

              then run contextBuilderCleaner

                given contextBuilderCleaner succeed

                  then emit contextBuilderCleanerSucceeded

                given contextBuilderCleaner failed

                  then emit contextBuilderCleanerFailed

```