whatap 1.0.1 → 1.0.2

package/lib/pack/statservice-rec.js

@@ -0,0 +1,292 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Pack            = require('./pack'),
+    PackEnum        = require('./packenum'),
+    IntKeyLinkedMap = require('../util/intkey-linkedmap'),
+    DataOutputX     = require('../io/data-outputx'),
+    DataInputX      = require('../io/data-inputx'),
+    IntKeyMap = require('../util/intkey-map'),
+    TimeCount      = require('./time-count');
+
+function TransactionRec() {
+    this.hash = 0; /*int*/
+
+    this.count = 0; /*int*/
+    this.error = 0; /*int*/
+
+    this.time_sum = 0; /*long*/
+    this.time_max = 0; /*int*/
+    
+    this.sql_count = 0; /*int*/
+    this.sql_time = 0; /*long*/
+    this.sql_fetch = 0; /*int*/
+    this.sql_fetch_time = 0; /*long*/
+
+    this.httpc_count = 0; /*int*/
+    this.httpc_time = 0; /*long*/
+    this.malloc_sum = 0; /*long*/
+    this.cpu_sum = 0; /*long*/
+
+    this.sqlMap = null;     // int-key-map
+    this.httpcMap = null;   // int-key-map
+
+    /*임시변수 서버전송 안함*/  
+    this.profiled = false;
+
+    this.apdex_satisfied = 0; /*int*/
+    this.apdex_tolerated = 0; /*int*/
+    
+    this.time_min = 0; /*int*/
+    this.time_std = Long.ZERO; /*long*/
+}
+
+TransactionRec.prototype.mergeForStat = function(o){
+    this.count += o.count;
+    this.error += o.error;
+    
+    this.time_sum +=o.time_sum;
+    this.time_max = Math.max(this.time_max, o.time_max);
+    
+    this.sql_count += o.sql_count;
+    this.sql_time +=o.sql_time;
+    this.sql_fetch += o.sql_fetch;
+    this.sql_fetch_time +=o.sql_fetch_time;
+    
+    this.httpc_count += o.httpc_count;
+    this.httpc_time +=o.httpc_time;
+    
+    this.malloc_sum +=o.malloc_sum;
+    this.cpu_sum +=o.cpu_sum;
+};
+
+TransactionRec.prototype.merge = function(o) {
+    this.mergeForStat(o);
+
+    if(o.sqlMap !== undefined && o.sqlMap.size() > 0){
+        if (this.sqlMap == undefined) {
+            this.sqlMap = createMap(o.sqlMap.size());
+            var en = o.sqlMap.entries();
+            while (en.hasMoreElements()) {
+                var e = en.nextElement();
+                this.sqlMap.put(e.getKey(), e.getValue().copy());
+            }
+        }else{
+            var en = o.sqlMap.entries();
+            while (en.hasMoreElements()) {
+                var e = en.nextElement();
+                var tc = this.sqlMap.get(e.getKey());
+                if (!tc) {
+                    this.sqlMap.put(e.getKey(), e.getValue().copy());
+                } else {
+                    tc.merge(e.getValue());
+                }
+            }
+        }
+    }
+};
+
+TransactionRec.prototype.setUrlHash = function(hash) {
+    this.hash = hash;
+    return this;
+};
+
+TransactionRec.prototype.write = function(dout) {
+        dout.writeInt(this.hash);
+        dout.writeByte(2);
+        dout.writeDecimal(this.count);
+        dout.writeDecimal(this.error);
+        dout.writeDecimal(this.time_sum);
+        dout.writeDecimal(this.time_max);
+        
+        dout.writeDecimal(this.sql_count);
+        dout.writeDecimal(this.sql_time);
+        dout.writeDecimal(this.sql_fetch);
+        dout.writeDecimal(this.sql_fetch_time);
+        
+        dout.writeDecimal(this.httpc_count);
+        dout.writeDecimal(this.httpc_time);
+        dout.writeDecimal(this.malloc_sum);
+        dout.writeDecimal(this.cpu_sum);
+
+        dout.writeDecimal(0);
+        dout.writeDecimal(0);
+};
+
+TransactionRec.prototype.read = function(din) {
+    this.hash = din.readInt();
+    var ver = din.readByte();
+    this.count = din.readDecNumber();
+    this.error = din.readDecNumber();
+    this.time_sum = din.readDecNumber();
+    this.time_max = din.readDecNumber();
+
+    this.sql_count = din.readDecNumber();
+    this.sql_time = din.readDecNumber();
+    this.sql_fetch = din.readDecNumber();
+    this.sql_fetch_time = din.readDecNumber();
+  
+    this.httpc_count = din.readDecNumber();
+    this.httpc_time = din.readDecNumber();
+    this.malloc_sum = din.readDecNumber();
+    this.cpu_sum = din.readDecNumber();
+
+    _drop(din);
+    _drop(din);
+    /*
+    var sqlcnt = din.readDecimal();
+    if (sqlcnt > 0) {
+        this.sqlMap = createMap(sqlcnt);
+        for (var i = 0; i < sqlcnt; i++) {
+            var hash = din.readInt();
+            this.sqlMap.put(hash, new TimeCount().read(din));
+        }
+    }
+    var httpcnt = din.readDecimal();
+    if (httpcnt > 0) {
+        this.httpcMap = createMap(httpcnt);
+        for (var i = 0; i < httpcnt; i++) {
+            var hash = din.readInt();
+            this.httpcMap.put(hash,  new TimeCount().read(din));
+        }
+    }
+
+    if(ver <=2) return this;
+	this.apdex_satisfied=  din.readDecimal();
+	this.apdex_tolerated=  din.readDecimal();
+
+    if(ver <=3) return this;
+	this.time_min= din.readDecimal();
+	this.time_std= din.readDecimal();
+    */
+    return this;
+};
+
+TransactionRec.readRec = function(din){
+    var urlHash = din.readInt();
+    var ver = din.readByte();
+
+    if(ver <= 1){
+        var profiled = (ver==1);
+        return;
+    }
+
+    var m = new TransactionRec(); 
+    m.hash = urlHash;
+    m.count = din.readDecimal();
+    m.error = din.readDecimal();
+    m.time_sum = din.readDecimal();
+    m.time_max = din.readDecimal();
+
+    m.sql_count = din.readDecimal();
+    m.sql_time = din.readDecimal();
+    m.sql_fetch = din.readDecimal();
+    m.sql_fetch_time = din.readDecimal();
+
+    m.httpc_count = din.readDecimal();
+    m.httpc_time = din.readDecimal();
+    m.malloc_sum = din.readDecimal();
+    m.cpu_sum = din.readDecimal();
+
+    var sqlcnt = din.readDecimal();
+    if (sqlcnt > 0) {
+        m.sqlMap = createMap(sqlcnt);
+        for (var i = 0; i < sqlcnt; i++) {
+            var hash = din.readInt();
+            m.sqlMap.put(hash, new TimeCount().read(din));
+        }
+    }
+    var httpcnt = din.readDecimal();
+    if (httpcnt > 0) {
+        m.httpcMap = createMap(httpcnt);
+        for (var i = 0; i < httpcnt; i++) {
+            var hash = din.readInt();
+            m.httpcMap.put(hash,  new TimeCount().read(din));
+        }
+    }
+    /*
+    if(ver <=2) return m;
+	m.apdex_satisfied=  din.readDecimal();
+	m.apdex_tolerated=  din.readDecimal();
+
+    if(ver <=3) return m;
+	m.time_min= din.readDecimal();
+	m.time_std= din.readDecimal();
+    */
+    return m;
+}
+
+TransactionRec.writeRec = function( o, m ) {
+    let ver = 2;
+    o.writeInt(m.hash);
+    o.writeByte(ver); //0,1 = old version
+    o.writeDecimal(m.count);
+    o.writeDecimal(m.error);
+    o.writeDecimal(m.time_sum);
+    o.writeDecimal(m.time_max);
+    o.writeDecimal(m.sql_count);
+    o.writeDecimal(m.sql_time);
+    o.writeDecimal(m.sql_fetch);
+    o.writeDecimal(m.sql_fetch_time);
+
+    o.writeDecimal(m.httpc_count);
+    o.writeDecimal(m.httpc_time);
+    o.writeDecimal(m.malloc_sum);
+    o.writeDecimal(m.cpu_sum);
+
+    if (m.sqlMap == null) {
+        o.writeDecimal(0);
+    } else {
+        o.writeDecimal(m.sqlMap.size());
+        var en = m.sqlMap.entries();        // IntKeyEntry
+        while (en.hasMoreElements()) {
+            var ent = en.nextElement();     // TimeCount
+            o.writeInt(ent.getKey());
+            ent.getValue().write(o);
+        }
+    }
+    if (m.httpcMap == null) {
+        o.writeDecimal(0);
+    } else {
+        o.writeDecimal(m.httpcMap.size());
+        var en = m.httpcMap.entries();      // IntKeyEntry
+        while (en.hasMoreElements()) {
+            var ent = en.nextElement();     // TimeCount
+            o.writeInt(ent.getKey());
+            ent.getValue().write(o);
+        }
+    }
+    /*
+    if(ver <=2) return;
+    o.writeDecimal(m.apdex_satisfied);
+    o.writeDecimal(m.apdex_tolerated);		
+
+    if(ver <=3) return;
+    o.writeDecimal(m.time_min);
+    o.writeDecimal(m.time_std);
+    */
+}
+
+TransactionRec.createMap = function(cnt) {
+    var m = new IntKeyMap(cnt);
+    m.create = function(key){
+        return this.size() >= 1000 ? null : new TimeCount();
+    }
+    return m;
+}
+
+function _drop(din){
+    var c = din.readDecNumber();
+     if (c > 0) {
+         for (i = 0; i < c; i++) {
+             din.readInt();
+             din.readDecNumber();
+             din.readDecNumber();
+             din.readDecNumber();
+         }
+     }
+}
+module.exports = TransactionRec;

package/lib/pack/statservice-rec_dep.js

@@ -0,0 +1,151 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Pack            = require('./pack'),
+    PackEnum        = require('./packenum'),
+    IntKeyLinkedMap = require('../util/intkey-linkedmap'),
+    DataOutputX     = require('../io/data-outputx'),
+    DataInputX      = require('../io/data-inputx'),
+    TimeCount      = require('./time-count');
+
+function TransactionRecDep() {
+    this.hash = 0; /*int*/
+
+    this.count = 0; /*int*/
+    this.error = 0; /*int*/
+
+    this.time_sum = 0; /*long*/
+    this.time_max = 0; /*int*/
+    
+    this.sql_count = 0; /*int*/
+    this.sql_time = 0; /*long*/
+    this.sql_fetch = 0; /*int*/
+    this.sql_fetch_time = 0; /*long*/
+    
+
+
+    this.httpc_count = 0; /*int*/
+    this.httpc_time = 0; /*long*/
+    this.malloc_sum = 0; /*long*/
+    this.cpu_sum = 0; /*long*/
+
+  /*임시변수 서버전송 안함*/  this.profiled = false;
+}
+
+TransactionRecDep.prototype.mergeForStat = function(o){
+    this.count += o.count;
+    this.error += o.error;
+    
+    this.time_sum +=o.time_sum;
+    this.time_max = Math.max(this.time_max, o.time_max);
+    
+    this.sql_count += o.sql_count;
+    this.sql_time +=o.sql_time;
+    this.sql_fetch += o.sql_fetch;
+    this.sql_fetch_time +=o.sql_fetch_time;
+    
+    this.httpc_count += o.httpc_count;
+    this.httpc_time +=o.httpc_time;
+    
+    this.malloc_sum +=o.malloc_sum;
+    this.cpu_sum +=o.cpu_sum;
+};
+
+TransactionRecDep.prototype.merge = function(o) {
+    this.count += o.count;
+    this.error += o.error;
+    this.time_sum +=o.time_sum;
+    this.time_max = Math.max(this.time_max, o.time_max);
+  
+    this.sql_count += o.sql_count;
+    this.sql_time +=o.sql_time;
+  
+    this.sql_fetch += o.sql_fetch;
+    this.sql_fetch_time +=o.sql_fetch_time;
+  
+    this.httpc_count += o.httpc_count;
+    this.httpc_time += o.httpc_time;
+  
+    this.malloc_sum += o.malloc_sum;
+    this.cpu_sum += o.cpu_sum;
+
+};
+
+TransactionRecDep.prototype.setUrlHash = function(hash) {
+    this.hash = hash;
+    return this;
+};
+
+TransactionRecDep.prototype.getDeviation = function() {
+    if (this.count === 0) {
+        return 0;
+    }
+    var avg = this.time_suthis.divide(this.count); /*long*/
+    var variation = (this.time_std - (2 * avg * this.time_sum) + (this.count * avg * avg)) / this.count;
+
+    // NAN check..
+    var ret = Math.sqrt(variation);
+    return isNaN(ret) ? 0 : ret;
+};
+
+
+TransactionRecDep.prototype.write = function(dout) {
+        dout.writeInt(this.hash);
+        dout.writeByte(2);
+        dout.writeDecimal(this.count);
+        dout.writeDecimal(this.error);
+        dout.writeDecimal(this.time_sum);
+        dout.writeDecimal(this.time_max);
+        
+        dout.writeDecimal(this.sql_count);
+        dout.writeDecimal(this.sql_time);
+        dout.writeDecimal(this.sql_fetch);
+        dout.writeDecimal(this.sql_fetch_time);
+        
+        dout.writeDecimal(this.httpc_count);
+        dout.writeDecimal(this.httpc_time);
+        dout.writeDecimal(this.malloc_sum);
+        dout.writeDecimal(this.cpu_sum);
+
+        dout.writeDecimal(0);
+        dout.writeDecimal(0);
+};
+TransactionRecDep.prototype.read = function(din) {
+    this.hash = din.readInt();
+    var ver = din.readByte();
+    this.count = din.readDecNumber();
+    this.error = din.readDecNumber();
+    this.time_sum = din.readDecNumber();
+    this.time_max = din.readDecNumber();
+
+    this.sql_count = din.readDecNumber();
+    this.sql_time = din.readDecNumber();
+    this.sql_fetch = din.readDecNumber();
+    this.sql_fetch_time = din.readDecNumber();
+  
+    this.httpc_count = din.readDecNumber();
+    this.httpc_time = din.readDecNumber();
+    this.malloc_sum = din.readDecNumber();
+    this.cpu_sum = din.readDecNumber();
+
+    _drop(din);
+    _drop(din);
+
+    return this;
+};
+
+function _drop(din){
+    var c = din.readDecNumber();
+     if (c > 0) {
+         for (i = 0; i < c; i++) {
+             din.readInt();
+             din.readDecNumber();
+             din.readDecNumber();
+             din.readDecNumber();
+         }
+     }
+}
+module.exports = TransactionRecDep;

package/lib/pack/statsql-pack.js

@@ -0,0 +1,69 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Pack        = require('./pack'),
+    PackEnum    = require('./packenum'),
+    DataOutputX = require('../io/data-outputx'),
+    DataInputX  = require('../io/data-inputx'),
+    SqlRec     = require('./statsql-rec');
+
+function StatSqlPack() {
+    Pack.call(this);
+    this.records = [];
+    this.record_count = 0;
+    return this;
+}
+
+StatSqlPack.prototype = new Pack();
+StatSqlPack.prototype.constructor = StatSqlPack;
+StatSqlPack.prototype.getPackType = function () {
+    return PackEnum.STAT_SQL;
+};
+
+StatSqlPack.prototype.write = function (dout) {
+    Pack.prototype.write.call(this, dout);
+    dout.writeBlob(this.records);
+    dout.writeDecimal(this.record_count);
+};
+StatSqlPack.prototype.read = function (din) {
+    Pack.prototype.read.call(this, din);
+    this.records = din.readBlob();
+    this.record_count = din.readDecNumber();
+    return this;
+};
+StatSqlPack.prototype.setRecords = function (size, items) {
+    var dout = new DataOutputX();
+    dout.writeShort(size);
+    while(items.hasMoreElements()) {
+        SqlRec.writeRec(dout, items.nextElement());
+        //items.nextElement().write(dout);
+    }
+    /*
+    for(var i=0; i<size; i++) {
+        items.nextElement().write(dout);
+    }
+    */
+    this.records = dout.toByteArray();
+    this.record_count = size;
+    return this;
+};
+StatSqlPack.prototype.getRecords = function () {
+    var items = [];
+    if(this.records == null) {
+        return items;
+    }
+
+    var din = new DataInputX(this.records);
+    var size = din.readShort();
+    for(var i=0; i<size; i++) {
+        var m = new SqlRec().read(din);
+        items.push(m);
+    }
+    return items;
+};
+
+
+module.exports = StatSqlPack;

package/lib/pack/statsql-rec.js

@@ -0,0 +1,100 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var BitUtil     = require('../util/bitutil');
+    
+function SqlRec() {
+    this.dbc = 0;
+    this.sql = 0;
+    this.sql_crud = 0;
+    this.count_total = 0;
+    this.count_error = 0;
+    //this.count_actived = 0;
+    this.time_sum = 0;
+    this.time_std = 0;
+    this.time_min = 0;
+    this.time_max = 0;
+    this.fetch_count = 0;
+    this.fetch_time = 0;
+    this.update_count = 0;
+    this.service = 0;
+}
+
+SqlRec.prototype.merge = function (other) {
+    this.count_total += other.count_total;
+    this.count_error += other.count_error;
+    //this.count_actived += other.count_actived;
+    this.time_sum +=other.time_sum;
+    this.time_std = other.time_std;
+    this.time_max = Math.max(this.time_max, other.time_max);
+    this.time_min = Math.min(this.time_min, other.time_min);
+    this.fetch_count += other.fetch_count;
+    this.fetch_time += other.fetch_time;
+    this.update_count +=other.update_count;
+};
+SqlRec.prototype.key = function () {
+    return BitUtil.composite(this.dbc, this.sql);
+};
+
+SqlRec.prototype.write = function (dout, m) {
+    dout.writeInt(this.dbc);
+    dout.writeInt(this.sql);
+    dout.writeByte(this.sql_crud);
+    dout.writeDecimal(this.count_total);
+    dout.writeDecimal(this.count_error);
+    dout.writeDecimal(-1);
+    dout.writeDecimal(this.time_sum);
+    dout.writeDecimal(this.time_std);
+    dout.writeDecimal(this.time_min);
+    dout.writeDecimal(this.time_max);
+    dout.writeDecimal(this.fetch_count);
+    dout.writeDecimal(this.fetch_time);
+    dout.writeDecimal(this.update_count);
+
+    dout.writeDecimal(this.service);
+};
+SqlRec.prototype.read = function (din) {
+    this.dbc = din.readInt();
+    this.sql = din.readInt();
+    this.sql_crud = din.readByte();
+    this.count_total = din.readDecNumber();
+    this.count_error = din.readDecNumber();
+    
+    var ver = din.readDecNumber();
+
+    this.time_sum = din.readDecNumber();
+    this.time_std = din.readDecNumber();
+    this.time_min = din.readDecNumber();
+    this.time_max = din.readDecNumber();
+    this.fetch_count = din.readDecNumber();
+    this.fetch_time = din.readDecNumber();
+    this.update_count = din.readDecNumber();
+    if(ver >=0){
+        return this;
+    }
+    this.service = din.readDecNumber();
+    return this;
+};
+
+SqlRec.writeRec = function (dout, m) {
+    dout.writeInt(m.dbc);
+    dout.writeInt(m.sql);
+    dout.writeByte(m.sql_crud);
+    dout.writeDecimal(m.count_total);
+    dout.writeDecimal(m.count_error);
+    dout.writeDecimal(-1);
+    dout.writeDecimal(m.time_sum);
+    dout.writeDecimal(m.time_std);
+    dout.writeDecimal(m.time_min);
+    dout.writeDecimal(m.time_max);
+    dout.writeDecimal(m.fetch_count);
+    dout.writeDecimal(m.fetch_time);
+    dout.writeDecimal(m.update_count);
+
+    dout.writeDecimal(m.service);
+};
+
+module.exports = SqlRec;

package/lib/pack/statuseragent-pack.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+var Pack        = require('./pack'),
+    PackEnum    = require('./packenum'),
+    IntIntMap   = require('../util/intint-map');
+
+function StatUserAgentPack() {
+    Pack.call(this);
+    this.userAgents = new IntIntMap();
+}
+
+StatUserAgentPack.prototype = new Pack();
+StatUserAgentPack.prototype.constructor = StatUserAgentPack;
+StatUserAgentPack.prototype.getPackType = function () {
+    return PackEnum.STAT_USER_AGENT;
+};
+StatUserAgentPack.prototype.write = function (dout) {
+    Pack.prototype.write.call(this, dout);
+
+    dout.writeDecimal(this.userAgents.size());
+    var en = this.userAgents.entries();
+    while(en.hasMoreElements()) {
+        var e = en.nextElement();
+        dout.writeInt(e.getKey());
+        dout.writeInt(e.getValue());
+    }
+};
+StatUserAgentPack.prototype.read = function (din) {
+    Pack.prototype.read.call(this, din);
+    var cnt = din.readDecNumber();
+    this.userAgents = new IntIntMap();
+    for(var i=0; i<cnt; i++) {
+        var ip = din.readInt();
+        var count = din.readInt();
+        this.userAgents.put(ip, count);
+    }
+    return this;
+};
+
+module.exports = StatUserAgentPack;

package/lib/pack/tagcount-pack.js

@@ -21,10 +21,10 @@ function TagCountPack() {
     this.originOid = null;
     this.tags = new MapValue()
     this.fields = new MapValue()
-    this.read_size;
-    this.fieldPos;
-    this.tagPos;
-    this.madeByPlugIn;
+    this.read_size
+    this.fieldPos
+    this.tagPos
+    this.madeByPlugIn
 }
 
 TagCountPack.prototype = new Pack();

package/lib/pack/tagctr.js

@@ -0,0 +1,15 @@
+/**
+ * Copyright 2016 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+function TagCtr() {
+    this.cache_last_only = "_cache_last_only_"
+    this.no_cache = "_no_cache_"
+    this.no_5m_hour = "_no_5m_hour_"
+    this.agency = "agency"
+    this.taglog = "taglog"
+};
+
+module.exports = TagCtr;