hapi-brakes

Plugin to simplify the circuit breaker system using Brakes library inside an Hapi.js environment.

To learn more about circuit breaker system, see Netflix Hystrix Wiki

There are other Hystrix's implementation in Node.js like HystrixJS

Settings

When registering the plugin, you can give custom settings or using the default values :

Default values

this settings that will be the default value for each circuitBreaker :

| Variable | Type | Default Value | Documentation | |---------------------|----------|-----------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------| | name | String | defaultBrake | hystrix command name, must be unique for each circuit within the same group. | | group | String | defaultBrakeGroup | Hystrix command group, used to group different command | | timeout | Number | 15000 | Time in ms before a service call will timeout | | threshold | Float | 0.5 | % threshold for successful calls. If the % of successful calls dips below this threshold the circuit will break | | waitThreshold | Number | 100 | Number of requests to wait before testing circuit health | | statInterval | Number | 1200 | Interval in ms that brakes should emit a snapshot event | | healthCheckInterval | Number | 5000 | Time in ms interval between each execution of health check function | | bucketSpan | Number | 1000 | Time in ms that a specific bucket should remain active | | bucketNum | Number | 60 | Number of buckets to retain in a rolling window | | percentiles | Number[] | [0.0, 0.25, 0.5, 0.75, 0.9, 0.95, 0.99, 0.995, 1] | Array that defines the percentile levels that should be calculated on the stats object (i.e. 0.9 for 90th percentile) | | circuitDuration | Number | 30000 | Time in ms that a circuit should remain broken | | isFailure | Function | null | Function used to determine if the function failed or not, must return a Boolean. | | healthCheck | Function | null | Function used to determine if the service is now available, must return a Promise. | | fallback | Function | null | Function executed if the service failed to deliver data, must return a Promise. | | isPromise | Boolean | false | to opt out of check for callback in function. This affects the passed in function, health check and fallback | | isFunction | Boolean | false | to opt out of check for callback, always promisifying in function. This affects the passed in function, health check and fallback |

Since it's a wrapper you can set the config as described in Brakes documentation

PS : i haven't tried the isPromise and isFunction option yet

Hystrix Route

You can enable/disable the Hystrix SSE Endpoint by setting the hystrixRoute when registering the plugin. It's a basic Hapi endpoint (see Hapi route documentation).

By passing hystrixRoute as false you'll disable the Hystrix route.

The default value is :

hystrixRoute : {
    method : 'GET',
    path   : '/hystrix',
    config : {
        tags : [ 'api', 'hystrix' ],
    }
}

Warning, if you are changing this value, keep in mind that i'll override your method value to GET and the handler or the Hystrix Dashboard will not recognize the SSE stream.

Example of config

config = {
    name : 'test',
    group : 'groupTest',
    timeout : 150000, // some people like waiting a long time
    threshold : 1 // if one calls fail, it will open the circuit
    hystrixRoute : {
        method : 'GET',
        path   : '/hystrix',
        config : {
            tags : [ 'someOtherFunnyTag' ]
            // other config's endpoint
        }
    }
}

Usage

The plugin will decorate Server with a circuitBreaker object that contains a wrap function and a circuits object.

wrap will return the Circuit object and add it to the server.circuitBreaker.circuits listing.

server.circuitBreaker = { 
    wrap: [Function],
    circuits: { 
        'The name of the group': { 
            'The name of the first circuit breaker': [Circuit],
            'The name of the second circuit breaker': [Circuit]
        } 
    } 
}

Reusing wrap with the same name and group as an other circuit will override the first one.

Examples

Wrapping a function inside a Circuit :

var circuit = server.circuitBreaker.wrap({
    name      : 'CircuitBreakerName', // Required
    group     : 'CircuitBreakerGroup', 
    timeout   : 2000, // 2s of timeout accepted
    threshold : 0.66, // if percentage of failed request is above 34%, it opens the circuit ( 1 - 0.66 = 0.34 ) 
    run       : (data) => { // the argument will be passed from the execution of the command ( see .exec() )
        return new Promise((fulfill, reject) => {
            request(data, (err, result) => {
                if (err || result.statusCode != 200) {
                    reject(err);
                    return;
                }
                fulfill(result);
            });
        });
    },
    isFailure : (err) => {
        // Do something to verify the error and decide to open or not the circuit
        // if the timeout is above the limit defined, the isFailure isn't called
        return true; // open it everytime
    },
    healthCheck : () => {
        return new Promise((fulfill, reject) => {
            // Do something to verify that the circuit could be closed
        }
    },
    fallback  : () => {
        return new Promise((resolve) => {
            resolve( 'something you want when the circuit is open, like asking a cache or something like that' );
        });
    }
});

Executing the function inside the circuit :

circuit.exec({
   uri  : 'http://0.0.0.0:' + '8080' + '/users/' + 5,  // params sent to the run method
   json : true,
   time : true
}).then((data) => {
   // Data came before timeout limit (but it could be fallback data !)
}).catch((err) => {
   // something happens
});

You can use the server.circuitBreaker.circuits to get the Circuit object :

server.circuitBreaker.circuits.CircuitBreakerGroup.CircuitBreakerName.exec({
    uri  : 'http://0.0.0.0:' + '8080' + '/users/' + 6, 
    json : true,
    time : true
}).then((data) => {
   // Data came before timeout limit (but it could be fallback data !)
}).catch((err) => {
   // something happens
});