brake-client
Version:
An client with circuit.
146 lines (126 loc) • 16.7 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = undefined;
var _Brakes = require('./Brakes');
var Brakes = _interopRequireWildcard(_Brakes);
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
let BrakeClient = class BrakeClient {
/**
*
* @param serviceName: string to use for name of circuit. This is mostly used for reporting on stats.
* @param options
* @param options.handler
* @param options.handler.preHandle
* @param options.handler.postHandle
* @param options.handler.postCircuit
* @param options.group: string to use for group of circuit. This is mostly used for reporting on stats.
* @param options.bucketSpan: time in ms that a specific bucket should remain active
* @param options.statInterval: interval in ms that brakes should emit a snapshot event
* @param options.percentiles: array<number> that defines the percentile levels that should be calculated on the stats object (i.e. 0.9 for 90th percentile)
* @param options.bucketNum: # of buckets to retain in a rolling window
* @param options.circuitDuration: time in ms that a circuit should remain broken
* @param options.waitThreshold: number of requests to wait before testing circuit health
* @param options.threshold: % threshold for successful calls. If the % of successful calls dips below this threshold the circuit will break
* @param options.timeout: time in ms before a service call will timeout
* @param options.isFailure: function that returns true if an error should be considered a failure (receives the error object returned by your command.) This allows for non-critical errors to be ignored by the circuit breaker
* @param options.healthCheckInterval: time in ms interval between each execution of health check function
* @param options.healthCheck: function to call for the health check (can be defined also with calling healthCheck function)
* @param options.fallback: function to call for fallback (can be defined also with calling fallback function)
* @param options.isPromise: boolean to opt out of check for callback in function. This affects the passed in function, health check and fallback
* @param options.isFunction: boolean to opt out of check for callback, always promisifying in function. This affects the passed in function, health check and fallback
*/
constructor(serviceName, options = {}) {
this.serviceName = serviceName;
this.options = options;
this.handler = options.handler;
this.brakes = Brakes.getBrakes(this.serviceName, this.options);
}
/**
*
* @param client
* @param fallback
* @param options
* @param options.handler
* @param options.handler.preHandle
* @param options.handler.postHandle
* @param options.handler.postCircuit
* @return {{send: function}}
*/
circuit(client, fallback, options = {}) {
var _this = this;
return {
send: (() => {
var _ref = _asyncToGenerator(function* (request) {
const handler = options.handler || _this.handler;
const circuit = _this.brakes.slaveCircuit((() => {
var _ref2 = _asyncToGenerator(function* (request) {
//pre handle request
if (handler && handler.preHandle) {
request = handler.preHandle(request) || request;
}
let err, response;
try {
response = yield client.send(request);
} catch (e) {
err = e;
}
//post handle response
if (handler && handler.postHandle) {
response = handler.postHandle(err, response) || response;
}
return response;
});
return function (_x2) {
return _ref2.apply(this, arguments);
};
})(), fallback ? function (...params) {
return fallback(...params);
} : undefined, options);
let response = yield circuit.exec(request);
if (handler && handler.postCircuit) {
response = handler.postCircuit(response);
}
return response;
});
return function send(_x) {
return _ref.apply(this, arguments);
};
})()
};
}
fallback(callback) {
return this.brakes.fallback(function (...params) {
return callback(...params);
});
}
healthCheck(callback) {
return this.brakes.healthCheck(function (...params) {
return callback(...params);
});
}
/**
*
* @param eventName
* exec: Event on request start
* failure: Event on request failure
* success: Event on request success
* timeout: Event on request timeout
* circuitClosed: Event fired when circuit is closed
* circuitOpen: Event fired when circuit is open
* snapshot: Event fired on stats snapshot
* healthCheckFailed: Event fired on failure of each health check execution
* @param callback
* @return {*}
*/
on(eventName, callback) {
return this.brakes.on(eventName, callback);
}
isOpen() {
return this.brakes.isOpen();
}
};
exports.default = BrakeClient;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/BrakeClient.js"],"names":["Brakes","BrakeClient","constructor","serviceName","options","handler","brakes","getBrakes","circuit","client","fallback","send","request","slaveCircuit","preHandle","err","response","e","postHandle","params","undefined","exec","postCircuit","callback","healthCheck","on","eventName","isOpen"],"mappings":";;;;;;;AAAA;;IAAYA,M;;;;;;IAESC,W,GAAN,MAAMA,WAAN,CAAkB;AAC7B;;;;;;;;;;;;;;;;;;;;;;;;AAwBAC,gBAAYC,WAAZ,EAAyBC,UAAU,EAAnC,EAAuC;AACnC,aAAKD,WAAL,GAAmBA,WAAnB;AACA,aAAKC,OAAL,GAAeA,OAAf;AACA,aAAKC,OAAL,GAAeD,QAAQC,OAAvB;AACA,aAAKC,MAAL,GAAcN,OAAOO,SAAP,CAAiB,KAAKJ,WAAtB,EAAmC,KAAKC,OAAxC,CAAd;AACH;;AAED;;;;;;;;;;;AAWAI,YAAQC,MAAR,EAAgBC,QAAhB,EAA0BN,UAAU,EAApC,EAAwC;AAAA;;AACpC,eAAO;AACHO;AAAA,6CAAM,WAAMC,OAAN,EAAiB;AACnB,0BAAMP,UAAUD,QAAQC,OAAR,IAAmB,MAAKA,OAAxC;AACA,0BAAMG,UAAU,MAAKF,MAAL,CAAYO,YAAZ;AAAA,sDAAyB,WAAMD,OAAN,EAAiB;AACtD;AACA,gCAAIP,WAAWA,QAAQS,SAAvB,EAAkC;AAC9BF,0CAAUP,QAAQS,SAAR,CAAkBF,OAAlB,KAA8BA,OAAxC;AACH;;AAED,gCAAIG,GAAJ,EAASC,QAAT;AACA,gCAAI;AACAA,2CAAW,MAAMP,OAAOE,IAAP,CAAYC,OAAZ,CAAjB;AACH,6BAFD,CAEE,OAAOK,CAAP,EAAU;AACRF,sCAAME,CAAN;AACH;;AAED;AACA,gCAAIZ,WAAWA,QAAQa,UAAvB,EAAmC;AAC/BF,2CAAWX,QAAQa,UAAR,CAAmBH,GAAnB,EAAwBC,QAAxB,KAAqCA,QAAhD;AACH;;AAED,mCAAOA,QAAP;AACH,yBAnBe;;AAAA;AAAA;AAAA;AAAA,0BAmBbN,WAAW,UAAU,GAAGS,MAAb,EAAqB;AAC/B,+BAAOT,SAAS,GAAGS,MAAZ,CAAP;AACH,qBAFE,GAECC,SArBY,EAqBDhB,OArBC,CAAhB;;AAuBA,wBAAIY,WAAW,MAAMR,QAAQa,IAAR,CAAaT,OAAb,CAArB;;AAEA,wBAAIP,WAAWA,QAAQiB,WAAvB,EAAoC;AAChCN,mCAAWX,QAAQiB,WAAR,CAAoBN,QAApB,CAAX;AACH;;AAED,2BAAOA,QAAP;AACH,iBAhCD;;AAAA;AAAA;AAAA;AAAA;AADG,SAAP;AAmCH;;AAEDN,aAASa,QAAT,EAAmB;AACf,eAAO,KAAKjB,MAAL,CAAYI,QAAZ,CAAqB,UAAU,GAAGS,MAAb,EAAqB;AAC7C,mBAAOI,SAAS,GAAGJ,MAAZ,CAAP;AACH,SAFM,CAAP;AAGH;;AAEDK,gBAAYD,QAAZ,EAAsB;AAClB,eAAO,KAAKjB,MAAL,CAAYkB,WAAZ,CAAwB,UAAU,GAAGL,MAAb,EAAqB;AAChD,mBAAOI,SAAS,GAAGJ,MAAZ,CAAP;AACH,SAFM,CAAP;AAGH;;AAED;;;;;;;;;;;;;;AAcAM,OAAGC,SAAH,EAAcH,QAAd,EAAwB;AACpB,eAAO,KAAKjB,MAAL,CAAYmB,EAAZ,CAAeC,SAAf,EAA0BH,QAA1B,CAAP;AACH;;AAEDI,aAAS;AACL,eAAO,KAAKrB,MAAL,CAAYqB,MAAZ,EAAP;AACH;AAjH4B,C;kBAAZ1B,W","file":"BrakeClient.js","sourcesContent":["import * as Brakes from './Brakes';\n\nexport default class BrakeClient {\n    /**\n     *\n     * @param serviceName:                 string to use for name of circuit. This is mostly used for reporting on stats.\n     * @param options\n     * @param options.handler\n     * @param options.handler.preHandle\n     * @param options.handler.postHandle\n     * @param options.handler.postCircuit\n     * @param options.group:               string to use for group of circuit. This is mostly used for reporting on stats.\n     * @param options.bucketSpan:          time in ms that a specific bucket should remain active\n     * @param options.statInterval:        interval in ms that brakes should emit a snapshot event\n     * @param options.percentiles:         array<number> that defines the percentile levels that should be calculated on the stats object (i.e. 0.9 for 90th percentile)\n     * @param options.bucketNum:           # of buckets to retain in a rolling window\n     * @param options.circuitDuration:     time in ms that a circuit should remain broken\n     * @param options.waitThreshold:       number of requests to wait before testing circuit health\n     * @param options.threshold:           % threshold for successful calls. If the % of successful calls dips below this threshold the circuit will break\n     * @param options.timeout:             time in ms before a service call will timeout\n     * @param options.isFailure:           function that returns true if an error should be considered a failure (receives the error object returned by your command.) This allows for non-critical errors to be ignored by the circuit breaker\n     * @param options.healthCheckInterval: time in ms interval between each execution of health check function\n     * @param options.healthCheck:         function to call for the health check (can be defined also with calling healthCheck function)\n     * @param options.fallback:            function to call for fallback (can be defined also with calling fallback function)\n     * @param options.isPromise:           boolean to opt out of check for callback in function. This affects the passed in function, health check and fallback\n     * @param options.isFunction:          boolean to opt out of check for callback, always promisifying in function. This affects the passed in function, health check and fallback\n     */\n    constructor(serviceName, options = {}) {\n        this.serviceName = serviceName;\n        this.options = options;\n        this.handler = options.handler;\n        this.brakes = Brakes.getBrakes(this.serviceName, this.options);\n    }\n\n    /**\n     *\n     * @param client\n     * @param fallback\n     * @param options\n     * @param options.handler\n     * @param options.handler.preHandle\n     * @param options.handler.postHandle\n     * @param options.handler.postCircuit\n     * @return {{send: function}}\n     */\n    circuit(client, fallback, options = {}) {\n        return {\n            send: async request => {\n                const handler = options.handler || this.handler;\n                const circuit = this.brakes.slaveCircuit(async request => {\n                    //pre handle request\n                    if (handler && handler.preHandle) {\n                        request = handler.preHandle(request) || request;\n                    }\n\n                    let err, response;\n                    try {\n                        response = await client.send(request);\n                    } catch (e) {\n                        err = e;\n                    }\n\n                    //post handle response\n                    if (handler && handler.postHandle) {\n                        response = handler.postHandle(err, response) || response;\n                    }\n\n                    return response;\n                }, fallback ? function (...params) {\n                    return fallback(...params);\n                } : undefined, options);\n\n                let response = await circuit.exec(request);\n\n                if (handler && handler.postCircuit) {\n                    response = handler.postCircuit(response);\n                }\n\n                return response;\n            }\n        }\n    }\n\n    fallback(callback) {\n        return this.brakes.fallback(function (...params) {\n            return callback(...params);\n        });\n    }\n\n    healthCheck(callback) {\n        return this.brakes.healthCheck(function (...params) {\n            return callback(...params);\n        });\n    }\n\n    /**\n     *\n     * @param eventName\n     *      exec:              Event on request start\n     *      failure:           Event on request failure\n     *      success:           Event on request success\n     *      timeout:           Event on request timeout\n     *      circuitClosed:     Event fired when circuit is closed\n     *      circuitOpen:       Event fired when circuit is open\n     *      snapshot:          Event fired on stats snapshot\n     *      healthCheckFailed: Event fired on failure of each health check execution\n     * @param callback\n     * @return {*}\n     */\n    on(eventName, callback) {\n        return this.brakes.on(eventName, callback);\n    }\n\n    isOpen() {\n        return this.brakes.isOpen();\n    }\n}"]}