whatap 1.0.1 → 1.0.2

package/lib/pack/errorsnap-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 PackEnum = require('./packenum'),
+    Pack = require('./pack'),
+    Step = require('../step/step'),
+    DataOutputX = require('../io/data-outputx'),
+    Long = require('long');
+
+function ErrorSnapPack1() {
+    Pack.call(this);
+    this.seq = Long.ZERO;
+    this.profile = null;
+    this.stack = null;
+    this.append_type = 0;
+    this.append_hash = 0;
+    this.setProfile = function(steps){
+        this.profile = Step.toBytes(steps);
+        return this;
+    };
+    this.setStack = function(callstacks) {
+        this.stack = new DataOutputX().writeIntArray(callstacks).toByteArray();
+        return this;
+    };
+    this.getProfile = function() {
+        return Step.toObjects(this.stack);
+    };
+    this.getStack = function() {
+        if( this.stack == null || this.stack.length === 0 ) {
+            return null;
+        }
+        return this.stack;
+    }
+}
+
+ErrorSnapPack1.prototype = new Pack();
+ErrorSnapPack1.prototype.constructor = ErrorSnapPack1;
+ErrorSnapPack1.prototype.toString = function() {
+    return "ErrorSnap " + Pack.prototype.toString.call(this)
+        + ", profile_bytes="
+        + ((this.profile != null) ? this.profile.length : 0)
+        + " stack_bytes="
+        + ((this.stack != null) ? this.stack.length : 0);
+};
+ErrorSnapPack1.prototype.getPackType = function () {
+    return PackEnum.ERROR_SNAP_1;
+};
+ErrorSnapPack1.prototype.write = function(dout) {
+    Pack.prototype.write.call(this, dout);
+    dout.writeLong(this.seq);
+    dout.writeBlob(this.profile);
+    dout.writeBlob(this.stack);
+    dout.writeByte(this.append_type);
+    dout.writeDecimal(this.append_hash);
+};
+ErrorSnapPack1.prototype.read = function(din) {
+    Pack.prototype.read.call(this, din);
+    this.seq = din.readLong();
+    this.profile = din.readBlob();
+    this.stack = din.readBlob();
+    this.append_type = din.readByte();
+    this.append_hash = din.readDecNumber();
+    return this;
+};
+
+module.exports = ErrorSnapPack1;

package/lib/pack/event-pack.js

@@ -0,0 +1,54 @@
+/**
+ * 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 PackEnum = require('./packenum'),
+    Pack = require('./pack');
+
+function EventPack() {
+    Pack.call(this);
+    this.level = 0;
+    this.title = '';
+    this.message = '';
+    this.attr = {};
+}
+EventPack.prototype = new Pack();
+EventPack.prototype.constructor = EventPack;
+EventPack.prototype.getPackType = function() {
+    return PackEnum.EVENT;
+};
+EventPack.prototype.write = function(dout) {
+    Pack.prototype.write.call(this, dout);
+
+    dout.writeByte(this.level);
+    dout.writeText(this.title);
+    dout.writeText(this.message);
+    dout.writeByte(Object.keys(this.attr).length);
+
+    for(var key in this.attr) {
+        dout.writeText(key);
+        dout.writeText(this.attr[key]);
+    }
+};
+EventPack.prototype.read = function(din) {
+    Pack.prototype.read.call(this, din);
+
+    this.level = din.readByte();
+    this.title = din.readText();
+    this.message = din.readText();
+
+    var keySize = din.readByte(),
+        key, value;
+
+    for(var i=0; i<keySize; i++) {
+        key = din.readText();
+        value = din.readText();
+        this.attr[key] = value;
+    }
+
+    return this;
+};
+
+module.exports = EventPack;

package/lib/pack/hitmap-pack.js

@@ -0,0 +1,63 @@
+/**
+ * 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 PackEnum = require('./packenum'),
+    Pack = require('./pack');
+
+function HitMapPack() {
+    this.hitCount = 0;
+    this.errorCount = 0;
+    this.hit = [];
+    this.error = [];
+    this.time90pct = 0;
+};
+
+HitMapPack.prototype.getPackType = function() {
+    return PackEnum.HITMAP;
+};
+HitMapPack.prototype.write = function(dout) {
+
+    Pack.prototype.write.call(this, dout);
+    dout.writeDecimal(this.hitCount);
+    dout.writeDecimal(this.errorCount);
+    dout.writeDecimal(this.time90pct);
+    this.writeIntArray(dout, this.hit);
+    this.writeIntArray(dout, this.error);
+};
+HitMapPack.prototype.read = function(din) {
+
+    Pack.prototype.read.call(this, din);
+    this.hitCount = din.readDecLong();
+    this.errorCount = din.readDecLong();
+    this.time90pct = din.readDecNumber();
+    this.readIntArray(din, this.hit);
+    this.readIntArray(din, this.error);
+
+    return this;
+};
+HitMapPack.prototype.writeIntArray = function(dout, v){
+
+    if(v == null) {
+        dout.writeByte(0);
+    } else {
+        dout.writeByte(v.length);
+        for(var val in v) {
+            dout.writeDecimal(val);
+        }
+    }
+};
+HitMapPack.prototype.readIntArray = function(din, map) {
+    var len = din.readByte();
+    for(var i=0; i<len; i++) {
+        if(i < map.length) {
+            map[i] = din.readDecNumber();
+        }
+    }
+};
+
+exports.Instance = HitMapPack;
+exports.PCT_BOX = 50;
+exports.HIT_MAP = 51;

package/lib/pack/hitmap-pack1.js

@@ -0,0 +1,152 @@
+/**
+ * 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'),
+    Logger = require('../logger');
+
+function HitMapPack1() {
+    Pack.call(this);
+    this.hit = new Array(HitMapPack1.LENGTH);
+    this.error = new Array(HitMapPack1.LENGTH);
+
+    this.hit.fill(0);
+    this.error.fill(0);
+}
+
+HitMapPack1.LENGTH = 120;
+HitMapPack1.prototype = new Pack();
+HitMapPack1.prototype.constructor = HitMapPack1;
+HitMapPack1.prototype.getPackType = function () {
+    return PackEnum.HITMAP_1;
+};
+HitMapPack1.prototype.write = function (dout) {
+    Pack.prototype.write.call(this, dout);
+    // dout.writeByte(1);
+    // for(var i=0; i<HitMapPack1.LENGTH; i++) {
+    //     dout.writeShort(this.hit[i]);
+    //     dout.writeShort(this.error[i]);
+    // }
+    dout.writeByte(3);// version
+	writeArr(dout, this.hit);
+	writeArr(dout, this.error);
+};
+HitMapPack1.prototype.read = function (din) {
+    Pack.prototype.read.call(this, din);
+    var ver = din.readByte();
+
+    if(ver === 1) {
+        for(var i=0; i<HitMapPack1.LENGTH; i++) {
+            this.hit[i] = din.readShort() & 0xffff;
+            this.error[i] = din.readShort() & 0xffff;
+        }
+    }
+    if(ver === 3){
+        readArr(din, this.hit);
+		readArr(din, this.error);
+    }
+    return this;
+};
+
+function writeArr( dout,  arr) {
+    try{
+        if (arr == null) {
+            dout.writeByte(0);
+        } else {
+            var len = HitMapPack1.LENGTH - 1;
+            for (; len >= 0; len--) {
+                if (arr[len] != 0)
+                    break;
+            }
+            len = len + 1;
+            dout.writeByte(len);
+            for (var i = 0; i < len; i++) {
+                dout.writeUInt16BE(arr[i]);
+            }
+        }
+    }catch (e) {
+        Logger.printError('WHATAP-088', 'Hit-map pack - write error', e, false);
+    }
+}
+
+function readArr( din, arr) {
+    var len = din.readByte() & 0xff;
+    for (var i = 0; i < len; i++) {
+        arr[i] = din.readShort() & 0xffff;
+    }
+}
+HitMapPack1.prototype.copy = function () {
+    var newOne = new HitMapPack1();
+    newOne.pcode = this.pcode;
+    newOne.oid = this.oid;
+    newOne.time = this.time;
+
+    newOne.hit = this.hit.slice();
+    newOne.error = this.error.slice();
+    return newOne;
+};
+HitMapPack1.prototype.merge = function (p) {
+    for(var i=0; i<this.LENGTH; i++) {
+        this.hit[i] += p.hit[i];
+        this.error[i] += p.error[i];
+    }
+};
+HitMapPack1.prototype.add = function (time, isError) {
+    var idx = HitMapPack1.index(time);
+    this.hit[idx]++;
+    if(isError) {
+        this.error[idx]++;
+    }
+};
+HitMapPack1.prototype.toString = function() {
+    return 'HitMap1 ' + Pack.prototype.toString.call(this) + ', hit=' + this.hit.length + ", error=" + this.error.length;
+};
+
+HitMapPack1.index = function (time) {
+    var x = parseInt(time / 10000);
+    switch (x) {
+        case 0:
+            if (time < 5000)
+                return parseInt(time / 125);
+            else
+                return 40 + parseInt((time - 5000) / 250);
+        case 1:
+            return 60 + parseInt((time - 10000) / 500);
+        case 2:
+        case 3:
+            return 80 + parseInt((time - 20000) / 1000);
+        case 4:
+        case 5:
+        case 6:
+        case 7:
+            return 100 + parseInt((time - 40000) / 2000);
+        default:
+            return 119;
+    }
+};
+HitMapPack1.time = function(index) {
+    var _time = 0;
+    if (index < 40)
+        return index * 125;
+    _time = 5000;
+    if (index < 60)
+        return _time + (index - 40) * 250;
+    _time = 10000;
+    if (index < 80)
+        return _time + (index - 60) * 500;
+
+    _time = 20000;
+    if (index < 100)
+        return _time + (index - 80) * 1000;
+
+    _time = 40000;
+    if (index < 120)
+        return _time + (index - 100) * 2000;
+    return 80000;
+};
+
+
+module.exports = HitMapPack1;

package/lib/pack/log-sink-pack.js

@@ -4,17 +4,18 @@ const MapValue = require('../value/map-value');
 const DataOutputX = require('../io/data-outputx');
 const DataInputX = require('../io/data-inputx');
 const HashUtil = require('../util/hashutil');
+const Value = require('../value/value');
 const BooleanValue = require('../value/boolean-value');
 
 function LogSinkPack() {
     Pack.call(this);
-    this.Category = '';
-    this.time = null;
+    this.category = '';
     this.tagHash = 0;
     this.tags = new MapValue();
     this.line = 0;
     this.content = '';
     this.fields = new MapValue();
+    this.dropped = false;
 }
 
 LogSinkPack.prototype = Object.create(Pack.prototype);
@@ -25,7 +26,7 @@ LogSinkPack.prototype.getPackType = function () {
 };
 
 LogSinkPack.prototype.toString = function () {
-    return `${Pack.prototype.toString.call(this)} [category=${this.Category}, tagHash=${this.tagHash}, tags=${this.tags}, content=${this.content}, fields=${this.fields}]`;
+    return `${Pack.prototype.toString.call(this)} [category=${this.category}, tagHash=${this.tagHash}, tags=${this.tags}, content=${this.content}, fields=${this.fields}]`;
 };
 
 LogSinkPack.prototype.getTagAsBytes = function () {
@@ -84,24 +85,13 @@ LogSinkPack.prototype.setContentBytes = function (d) {
 
 LogSinkPack.prototype.write = function (dout) {
     Pack.prototype.write.call(this, dout);
-
     dout.writeByte(0);
-    dout.writeText(this.Category);
-
-    if (this.tagHash === 0 && this.tags.size() > 0) {
-        const result = this.resetTagHash();
-        this.tagHash = result.tagHash;
-        dout.writeDecimal(result.tagHash);
-        dout.write(result.tagBytes);
-    } else {
-        dout.writeDecimal(this.tagHash);
-        dout.writeValue(this.tags);
-    }
-
+    dout.writeText(this.category);
+    dout.writeDecimal(this.tagHash);
+    dout.writeValue(this.tags);
     dout.writeDecimal(this.line);
     dout.writeText(this.content);
-
-    if (this.fields && this.fields.size() > 0) {
+    if (this.fields.size() > 0) {
         dout.writeBoolean(true);
         dout.writeValue(this.fields);
     } else {
@@ -112,7 +102,7 @@ LogSinkPack.prototype.write = function (dout) {
 LogSinkPack.prototype.read = function (din) {
     Pack.prototype.read.call(this, din);
     const ver = din.readByte();
-    this.Category = din.readText();
+    this.category = din.readText();
     this.tagHash = din.readDecimal();
     this.tags = din.readValue();
     this.line = din.readDecimal();
@@ -124,11 +114,11 @@ LogSinkPack.prototype.read = function (din) {
 };
 
 LogSinkPack.prototype.resetTagHash = function () {
-    const dout = new DataOutputX();
-    dout.writeValue(this.tags);
-    const tagBytes = dout.toByteArray();
-    const tagHash = HashUtil.hash(tagBytes);
-    return { tagHash: tagHash, tagBytes: tagBytes };
+    const out = new DataOutputX();
+    out.writeValue(this.tags);
+    const tagBytes = out.toByteArray();
+    this.tagHash = HashUtil.hash64(tagBytes);
+    return tagBytes;
 };
 
 LogSinkPack.prototype.transferOidToTag = function () {
@@ -146,32 +136,4 @@ LogSinkPack.prototype.transferOidToTag = function () {
     }
 };
 
-LogSinkPack.getLogSinkPack = function(options) {
-    const {
-        t = 0,
-        category = null,
-        tags = {},
-        fields = {},
-        line = 0,
-        content = null
-    } = options || {};
-
-    const pack = new LogSinkPack();
-    pack.time = t;
-    pack.Category = category;
-
-    for (const [k, v] of Object.entries(tags)) {
-        pack.tags.putString(k, String(v));
-    }
-
-    for (const [k, v] of Object.entries(fields)) {
-        pack.fields.putString(k, String(v));
-    }
-
-    pack.line = line;
-    pack.content = content;
-
-    return pack;
-};
-
 module.exports = LogSinkPack;

package/lib/pack/netstat.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 NETSTAT(){
+    this.est = 0;
+    this.fin_w = 0;
+    this.tim_w = 0;
+    this.clo_w = 0;
+}
+
+
+module.exports = NETSTAT;

package/lib/pack/otype.js

@@ -0,0 +1,7 @@
+exports.AP     = 0x0001;
+exports.SM     = 0x0002;
+exports.DB     = 0x0004;
+exports.VR     = 0x0008;
+exports.CL     = 0x0010;
+exports.BSM    = 0x0011;
+exports.WC     = 0x0012;

package/lib/pack/profile-pack.js

@@ -0,0 +1,49 @@
+/**
+ * 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 PackEnum = require('./packenum'),
+    Pack = require('./pack'),
+    TxRecord = require('../service/tx-record'),
+    Step = require('../step/step');
+
+function ProfilePack() {
+    Pack.call(this);
+    this.service = null;
+    this.steps = null;
+}
+
+ProfilePack.prototype = new Pack();
+ProfilePack.prototype.constructor = ProfilePack;
+ProfilePack.prototype.toString = function() {
+    var text = 'Profile '
+        + Pack.prototype.toString.call(this)
+        + ', step_bytes='
+        + ((this.steps != null) ? this.steps.length : 0);
+    if (this.service != null) {
+        text += " time=" + this.service.endTime + ", active=" + this.service.active;
+    }
+    return text;
+};
+ProfilePack.prototype.getPackType = function() {
+    return PackEnum.PROFILE;
+};
+ProfilePack.prototype.write = function(dout) {
+    Pack.prototype.write.call(this, dout);
+    this.service.write(dout);
+    dout.writeBlob(this.steps);
+};
+ProfilePack.prototype.read = function(din) {
+    Pack.prototype.read.call(this, din);
+    this.service = new TxRecord().read(din);
+    this.steps = din.readBlob();
+    return this;
+};
+ProfilePack.prototype.setProfile = function(steps) {
+    this.steps = Step.toBytes(steps);
+    return this;
+};
+
+module.exports = ProfilePack;

package/lib/pack/realtimeuser-pack.js

@@ -0,0 +1,41 @@
+/**
+ * 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 PackEnum    = require('./packenum'),
+    Pack        = require('./pack'),
+    DataOutputX = require('../io/data-outputx'),
+    DataInputX  = require('../io/data-inputx');
+
+function RealTimeUserPack(rType) {
+    this.cadinality;
+    Pack.call(this);
+    this.logbits = null;
+}
+
+RealTimeUserPack.prototype = new Pack();
+RealTimeUserPack.prototype.constructor = RealTimeUserPack;
+RealTimeUserPack.prototype.toString = function() {
+    return 'RealtimeUserPack '
+        + Pack.prototype.toString.call(this)
+        + ', logbits='
+        + (this.logbits != null ? this.logbits.length : 0);
+};
+RealTimeUserPack.prototype.getPackType = function() {
+    return PackEnum.REALTIME_USER_1; //<-- 버전업함 
+};
+RealTimeUserPack.prototype.write = function(dout) {
+    Pack.prototype.write.call(this, dout);
+    dout.writeBlob(this.logbits);
+    dout.writeDecimal(this.cadinality);
+};
+RealTimeUserPack.prototype.read = function(din) {
+    Pack.prototype.read.call(this, din);
+    this.logbits = din.readBlob();
+    this.cadinality= din.readDecNumber();
+    return this;
+};
+
+module.exports = RealTimeUserPack;

package/lib/pack/stat-general-pack.js

@@ -0,0 +1,96 @@
+/**
+ * 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'),
+    AnyList   = require('../util/anylist');
+    StringKeyLinkedMap   = require('../util/stringkey-linkedmap');
+
+function  StatGeneralPack() {
+    Pack.call(this);
+    this.id = "";
+    this.data = new StringKeyLinkedMap();
+    this.dataBytes = null;
+    this.dataBytesSize = 0;
+}
+
+StatGeneralPack.prototype = new Pack();
+StatGeneralPack.prototype.constructor = StatGeneralPack;
+StatGeneralPack.prototype.getPackType = function () {
+    return PackEnum.STAT_GENERAL;
+};
+StatGeneralPack.prototype.write = function (dout) {
+    Pack.prototype.write.call(this, dout);
+
+    dout.writeText(this.id);
+    if(this.dataBytes == null){
+        this.dataBytes = writeTable(this.data);
+        this.dataBytesSize = this.dataBytes.length;
+    }
+   dout.writeInt24BE(this.dataBytesSize);
+   dout.write(this.dataBytes);
+};
+function writeTable(data) {
+    var dd = new DataOutputX();
+    dd.writeShort(data.size());
+    var en = data.entries();
+    while (en.hasMoreElements()) {
+       var ent = en.nextElement();
+        dd.writeText(ent.getKey());
+        dd.writeByte(ent.getValue().getType()); // type
+        ent.getValue().write(dd); // data
+    }
+    return dd.toByteArray();
+}
+StatGeneralPack.prototype.read = function (din) {
+    Pack.prototype.read.call(this, din);
+    this.id = din.readText();
+    this.dataBytesSize = din.readInt24BE();
+    this.dataBytes = din.read(this.dataBytesSize);
+    return this;
+};
+function readTable( bytes, data) {
+    var din = new DataInputX(bytes);
+    var cnt = din.readShort();
+    for (var i = 0; i < cnt; i++) {
+        var key = din.readText();
+        var a = new AnyList(din.readByte());
+        a.read(din);
+        data.put(key, a);
+    }
+    return cnt;
+}
+StatGeneralPack.prototype.unpack = function() {
+    if (this.dataBytes != null) {
+        readTable(this.dataBytes, this.data);
+        this.dataBytes = null;
+        this.dataBytesSize = 0;
+    }
+}
+
+StatGeneralPack.prototype.toString = function () {
+    var str = "StatGeneral ";
+    str += Pack.prototype.toString.call(this);
+    str += ", useragents=";
+    str += this.userAgents.size();
+    return str;
+};
+StatGeneralPack.prototype.put = function (key, data) {
+    this.data.put(key, data);
+};
+
+StatGeneralPack.prototype.get = function (key) {
+    this.unpack();
+    return this.data.get(key);
+};
+
+StatGeneralPack.prototype.isEmpty = function () {
+    return this.dataBytesSize == 0 && this.data.isEmpty();
+};
+
+module.exports = StatGeneralPack;