├── .npmignore
├── test
    ├── line.png
    ├── index.js
    └── index.html
├── package.json
├── index.js
└── README.md


/.npmignore:
--------------------------------------------------------------------------------
1 | *.png


--------------------------------------------------------------------------------
/test/line.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/fefeding/ema-timeout/HEAD/test/line.png


--------------------------------------------------------------------------------
/test/index.js:
--------------------------------------------------------------------------------
 1 | 
 2 | const ema = require('../index.js').create({
 3 |         Tavg: 60,
 4 |         Thwm: 250,
 5 |         Tmax: 500,
 6 |         N: 90
 7 | });
 8 | 
 9 | for(var i=0;i<100;i++) {
10 |     var a = Math.random() * 200;
11 |     var e = ema.update(a);
12 |     var t = ema.get();
13 |     console.log(a, e, t);
14 | }
15 | 
16 | for(var i=0;i<100;i++) {
17 |     var a = Math.random() * 200 + 500;
18 |     var e = ema.update(a);
19 |     var t = ema.get();
20 |     console.log(a, e, t);
21 | }


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "ema-timeout",
 3 |   "version": "1.0.3",
 4 |   "description": "通过ema算法动态计算延时时间",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "node ./test/index.js"
 8 |   },
 9 |   "repository": {
10 |     "type": "git",
11 |     "url": "git+https://github.com/jiamao/ema-timeout.git"
12 |   },
13 |   "keywords": [
14 |     "ema",
15 |     "动态超时"
16 |   ],
17 |   "author": "jiamao",
18 |   "license": "MIT",
19 |   "bugs": {
20 |     "url": "https://github.com/jiamao/ema-timeout/issues"
21 |   },
22 |   "homepage": "https://github.com/jiamao/ema-timeout#readme"
23 | }
24 | 


--------------------------------------------------------------------------------
/index.js:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * 创建EMA算法对象
 4 |  * 适应循环执行，程序大部分在等待响应，有柔性处理
 5 |  * 
 6 |  * @param {Object} options 格式 {
 7 |  *      Tavg: 最低响应时间， 一般用平均响应时间替代 (ms)
 8 |  *      Thwm：超时时间限制， 确保最坏的时候，所有请求能处理。正常时正确处理的成功率满足需求。 (ms)
 9 |  *      Tmax: 最大弹性时间 (ms)
10 |  *      N: 平滑指数，越小表示平无值越受最近值的影响，太大则对异常响应较慢
11 |  * }
12 |  */
13 | exports.create = function(options) {
14 |     options = Object.assign({
15 |         Tavg: 60,
16 |         Thwm: 250,
17 |         Tmax: 500,
18 |         N: 80
19 |     }, options);
20 | 
21 |     return {
22 |         options: options,
23 |         ema: 0, // 当前ema值
24 |         r: 2/(options.N + 1),   // 平滑指数
25 |         /**
26 |          * 更新最近延时时间 ， 计算当前ema
27 |          * @param {*} x 当前延时时间 (ms)
28 |          */
29 |         update: function(x) {
30 |             var ema = x * this.r + this.ema * (1 - this.r);
31 |             return this.ema = ema;
32 |         },
33 |         /**
34 |          * 获取当前延时时间 (ms)
35 |          * @returns {Number} 延时时间(ms)
36 |          */
37 |         get: function() {
38 |             var tdto = 0; // 当前延时间间
39 |             //  EMA <= Tavg， 这种情况EMA评估值比Tavg还要少，按耗时越少，给的延时越多的原则来计算，当前给的延时时间为Tmax。
40 |             if(this.ema <= this.options.Tavg) tdto = this.options.Tmax;    
41 |             // EMA >= Thwm, 这种情况下，网络抖动比较严重，直接把延时限制在Thwm上，加快失败，方便进行柔性处理。
42 |             else if(this.ema >= this.options.Thwm) {
43 |                 tdto = this.options.Thwm;
44 |             }
45 |             // EMA > Tavg, 这种情况EMA估值已经大于平均延时，此时启用动态延时计算
46 |             else {
47 |                 var p = (this.options.Thwm - this.ema) / (this.options.Thwm - this.options.Tavg); // 平无表现相对限制的偏移比例，相当于弹性
48 |                 tdto = this.options.Thwm + p * (this.options.Tmax - this.options.Thwm);
49 |             }
50 |             return Math.abs(tdto);
51 |         }
52 |     }
53 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # ema超时算法
 3 | 
 4 | [![NPM version][npm-image]][npm-url]
 5 | [![npm download][download-image]][download-url]
 6 | 
 7 | [npm-image]: https://img.shields.io/npm/v/ema-timeout.svg?style=flat-square
 8 | [npm-url]: https://npmjs.org/package/ema-timeout
 9 | [download-image]: https://img.shields.io/npm/dm/ema-timeout.svg?style=flat-square
10 | [download-url]: https://npmjs.org/package/ema-timeout
11 | 
12 | EMA算法本身是多用于金融行业的，是一种基于增加期望的模型。算法的主要思想是综合利用历史上积累到的数据，预测下一个周期内的期望。我们参考了标准的EMA算法，得到了符合互联网业务特点的用于超时控制的EMA算法。具体的思想主要是引入“平均效应”的概念，用平均响应时间代替固定超时时间，只要平均响应时间没有超时即可，而不是要求每次都不能超时。主要几点：总体情况不能超标；平均情况表现越好，弹性越大；平均情况表现越差，弹性越小。这里的弹性指的是允许毛刺情况的最大响应时间。
13 | 
14 | - 数据效果展示：[https://jiamao.github.io/ema-timeout/test/index.html](https://jiamao.github.io/ema-timeout/test/index.html)
15 | ![效果图](https://raw.githubusercontent.com/jiamao/ema-timeout/master/test/line.png)
16 | 
17 | ## Install
18 | 
19 | ```bash
20 | $ npm i ema-timeout --save
21 | ```
22 | 
23 | ## Usage
24 | 
25 | ```js
26 | const ema = require('ema-timeout');
27 | 
28 | // 因为每个cgi有可能不一样，根据自身业务需求考虑是否要为每个接口create不同的ema计算
29 | const options = {
30 |         Tavg: 55,   //  最低响应时间， 一般用平均响应时间替代
31 |         Thwm: 300,  // 超时时间限制， 确保最坏的时候，所有请求能处理。正常时正确处理的成功率满足需求。
32 |         Tmax: 500,  // 最大弹性时间
33 |         N: 90   // 平滑指数，越小表示平均值越受最近值的影响，太大则对异常响应较慢
34 |     };
35 | const emaObj = ema.create(options);
36 | 
37 | ```
38 | ```js
39 | const start = Date.now();
40 | let tdto = emaObj.get(); // 获取当前超时设置时间
41 | 
42 | // 请求接口指定超时时间
43 | // 这里是你业务请求逻辑
44 | try {
45 |     const result = await request({
46 |         timeout: tdto
47 |     });// 请求接口 
48 | 
49 |     emaObj.update(Date.now() - start); // 这里是更新当前接口延时时间，以备计算后续超时
50 | }
51 | catch(e) {
52 |     // 把异常指定为最大超时，这样更好的反应接口健康情况
53 |     emaObj.update(Math.max(Date.now() - start, options.Tmax)); 
54 | }    
55 | 
56 | ```
57 | 
58 | ## 适用条件
59 | 
60 | 固定业务逻辑，循环执行，如FastCGI/S++。
61 | 
62 | 程序大部分时间在等待响应，而不是CPU计算或处理I/O中断。
63 | 
64 | 服务是串行处理模式，容易受异常、慢请求阻塞。
65 | 
66 | 响应时间不宜波动过大。
67 | 
68 | 可以接受有损服务。
69 | 
70 | ## License
71 | 
72 | [MIT](LICENSE)
73 | 


--------------------------------------------------------------------------------
/test/index.html:
--------------------------------------------------------------------------------
  1 | <!doctype html>
  2 | <html style="height:100%;margin:0;">
  3 | <head>
  4 | <meta charset="utf-8">
  5 | <title>ema数据</title>
  6 | <meta name="description" content=""/>
  7 | <meta name="keywords" content=""/>
  8 | <meta name="format-detection" content="telephone=no" />
  9 | <meta name="apple-mobile-web-app-capable" content="yes">
 10 | <meta name="apple-mobile-web-app-status-bar-style" content="black">
 11 | <meta name="viewport" content="width=device-width,initial-scale=1, minimum-scale=1.0, maximum-scale=1, user-scalable=no"/>
 12 | <script src="https://jiamao.github.io/jmgraph/dist/jmgraph.min.js"></script>
 13 | <script>
 14 | //生成ajax请求
 15 |     //time 延时多少毫秒
 16 |     window.httpRequest = function(url, callback, time) {
 17 |         var xmlHttp;
 18 |         if (window.ActiveXObject) {
 19 |             xmlHttp = new ActiveXObject("Microsoft.XMLHTTP");
 20 |         }
 21 |         else if (window.XMLHttpRequest) {
 22 |             xmlHttp = new XMLHttpRequest();
 23 |         }
 24 |         if(!xmlHttp) {
 25 |             callback(null);
 26 |             return;
 27 |         }
 28 |         xmlHttp.onreadystatechange=function(e){
 29 |             if(this.readyState == 4) {
 30 |                 if(this.status == 200) {
 31 |                     callback&&callback(this.responseText||this.response);
 32 |                 }
 33 |                 else {
 34 |                     callback&&callback();
 35 |                 }
 36 |             }
 37 |         };
 38 |         xmlHttp.open("GET",url,true);
 39 |         //缓存中没有,指定了需要TAG处理，则优先返回，并延时处理资源
 40 |         if(time) {
 41 |             //css延时请求，因为如果缓存中没有的话，会直接生成link标签保证加载顺序
 42 |             setTimeout(function(){
 43 |                 xmlHttp.send(null);
 44 |             }, time);
 45 |         }
 46 |         else {
 47 |             xmlHttp.send(null);
 48 |         }
 49 |         return xmlHttp;
 50 |     }
 51 |     // 加载模块
 52 |     function require(url, callback) {
 53 |         window.httpRequest(url, function(js) {
 54 |             if(!js) {
 55 |                 callback && callback(null);
 56 |                 return;
 57 |             }
 58 |             var module = {};
 59 |             var exports = {};
 60 |             module.exports = exports;
 61 |             var f = new Function('module', 'exports', js);
 62 |             f(module, exports);
 63 |             callback(module.exports);
 64 |         });
 65 |     }
 66 | </script>
 67 | </head>
 68 | <body>
 69 | <div id="mycanvas" style="margin:10px;margin-top: 50px;width:100%;height:400px;"></div>
 70 | <div style="display:inline;">
 71 | <div style="background:#FF00FF; width:20px; height:2px;display: inline-block;"></div> Tavg: 最低响应时间 <br />
 72 | <div style="background:#FF9900; width:20px; height:2px;display: inline-block;"></div> Thwm: 超时时间限制 <br />
 73 | <div style="background:#000; width:20px; height:2px;display: inline-block;color:#fff;"></div> Tmax: 最大弹性时间 <br />
 74 | <div style="background:#00FFFF; width:20px; height:2px;display: inline-block;"></div> EMA: 平均响应时间 <br />
 75 | <div style="background:#FF0000; width:20px; height:2px;display: inline-block;"></div> Tdto: 动态超时时长 <br />
 76 | <div style="background:#0DAF43; width:20px; height:2px;display: inline-block;"></div> 当前延时
 77 | </div>
 78 | </body>
 79 | <script>
 80 | 
 81 | var graph = jmGraph.create('mycanvas', {
 82 |         width: 600,
 83 |         height: 400
 84 |     });
 85 | var margin = {
 86 |         left: 40,
 87 |         top: 100,
 88 |         bottom: 20,
 89 |         right: 20
 90 |     };
 91 | 
 92 | var options = {
 93 |         Tavg: 55,
 94 |         Thwm: 300,
 95 |         Tmax: 500,
 96 |         N: 90
 97 |     };
 98 | require('../index.js', function(ema) {
 99 |     /*          Tavg: 最低响应时间， 一般用平均响应时间替代 (ms)
100 |         *      Thwm：超时时间限制， 确保最坏的时候，所有请求能处理。正常时正确处理的成功率满足需求。 (ms)
101 |         *      Tmax: 最大弹性时间 (ms)
102 |         *      N: 平滑指数，越小表示平无值越受最近值的影响，太大则对异常响应较慢
103 |         */
104 |     
105 |     var instance = ema.create(options);
106 | 
107 |     var srcData = [];
108 |     var emaData = [];
109 |     var tdtoData = [];
110 | 
111 |     var bezier = graph.createShape('bezier');
112 |     for(var i=0;i<800;i++) {
113 |         var t = Math.random() * 50 + 30;
114 |         
115 | 
116 |         // 人为制造一个异常波
117 |         if(i == 100) {
118 |             bezier.cpoints = [
119 |                 {x: 20, y: t},
120 |                 {x: 22, y: 550},
121 |                 {x: 40, y: 800},
122 |                 {x: 60, y: 580},
123 |                 {x: 80, y: t}
124 |             ];
125 |             var cps = bezier.initPoints();
126 |             srcData = srcData.concat(cps.map(function(p){return p.y + Math.random() * 80;}));
127 |         } 
128 |         else if(i < srcData.length - 1) {
129 |             //t += 200 * Math.random();
130 | 
131 |             if(i > 200 && i < 220) t += 400;
132 | 
133 |             if(i > 400 && i < 405) t += 400;
134 |         } 
135 |         srcData.push(t); // 时时间
136 |     }
137 | 
138 |     /*for(var i=0;i<1000;i++) {
139 |         var t = Math.random() * 50 + 30;
140 |         if(i == 40 || i == 80) t += 600;
141 |         if(i > 100) {
142 |             if(i < 300) {
143 |                 t += i * 1.5;
144 |                 if(i == 200) t = 100;
145 |             }
146 |             else if(i < 500){
147 |                 t += (500-i) * 1.5;
148 |             }
149 |         }
150 |        
151 | 
152 |         srcData.push(t); // 时时间
153 |     }*/
154 | 
155 |     for(var i=0;i<srcData.length;i++) {
156 |         var tdto = instance.get();
157 |         
158 |         emaData.push(instance.ema);
159 |         tdtoData.push(tdto);
160 | 
161 |         instance.update(srcData[i]);
162 |     }
163 | 
164 |     draw(srcData, emaData, tdtoData);
165 | });
166 | 
167 | function draw(srcData, emaData, tdtoData) {
168 |     var style = {
169 |         stroke:'#000',
170 |         lineWidth: 2
171 |     };
172 |     //style.shadow = '0,0,5,#ccc';
173 |     //style.opacity = 0.8;
174 |     //graph.createShadow('shadow(0,0,10,#000)');//new jmShadow('shadow(10,10,20,#000)');
175 |     //style.shadow = graph.createShadow(4,4,6,'#000000');
176 |     //style.lineCap = 'round';
177 | 
178 |     var rect = graph.createShape('rect', {
179 |         position: {
180 |             x: margin.left,
181 |             y: 0
182 |         },
183 |         width: graph.width - margin.left - margin.right,
184 |         height: graph.height - margin.bottom
185 |     });
186 |     graph.children.add(rect);
187 | 
188 |     var tmaxy = convertPosY(options.Tmax);
189 |     var tmaxline = graph.createLine({x:margin.left,y: tmaxy},{x: graph.width - margin.right,y:tmaxy},style);
190 |     graph.children.add(tmaxline);
191 | 
192 |     var tavgy = convertPosY(options.Tavg);
193 |     style = graph.util.clone(style);
194 |     style.stroke = '#FF00FF';
195 |     var tavgline = graph.createLine({x:margin.left,y: tavgy},{x: graph.width - margin.right,y:tavgy},style);
196 |     graph.children.add(tavgline);
197 | 
198 |     var thwmy = convertPosY(options.Thwm);
199 |     style = graph.util.clone(style);
200 |     style.stroke = '#FF9900';
201 |     var thwmline = graph.createLine({x:margin.left,y: thwmy},{x: graph.width - margin.right,y:thwmy},style);
202 |     graph.children.add(thwmline);
203 | 
204 |     style = graph.util.clone(style);
205 |     style.stroke = '#0DAF43';
206 |     var p = createLine(srcData, style);
207 |     graph.children.add(p);
208 | 
209 |     style = graph.util.clone(style);
210 |     style.stroke = '#00FFFF';
211 |     var p = createLine(emaData, style);
212 |     graph.children.add(p);
213 | 
214 |     style = graph.util.clone(style);
215 |     style.stroke = '#FF0000';
216 |     var p = createLine(tdtoData, style);
217 |     graph.children.add(p);
218 | 
219 |     graph.redraw();
220 | }
221 | 
222 | function createLine(data, style) {
223 |     var points = [];
224 |     var step = (graph.width - margin.left - margin.right) / (data.length - 1);
225 |     for(var i=0;i<data.length;i++) {
226 |         points.push({
227 |             x: step * i + margin.left,
228 |             y: convertPosY(data[i])
229 |         });
230 |     }
231 |     var p = graph.createPath(points, style);
232 |     return p;
233 | }
234 | 
235 | function convertPosY(value) {
236 |     var h = graph.height - margin.top - margin.bottom;
237 |     return h - value / options.Tmax * h + margin.top;
238 | }
239 | </script>
240 | </html>
241 | 


--------------------------------------------------------------------------------