whatap 1.0.1 → 1.0.2

package/lib/counter/task/systemperf.js

@@ -0,0 +1,43 @@
+/**
+ * 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 CounterTask     = require('./counter-task'),
+    ResourceProfile = require('./../../util/resourceprofile'),
+    KubeUtil            = require('./../../util/kube-util'),
+    SecurityMaster  = require('../../net/security-master');
+
+function SystemPerf(){
+    CounterTask.call(this);
+}
+
+SystemPerf.prototype = new CounterTask();
+SystemPerf.prototype.constructor = SystemPerf;
+SystemPerf.prototype.process = function(p) {
+    var cpu = ResourceProfile.getCPU();
+    if (cpu == null) return;
+
+    p.cpu = cpu.usage;
+    p.cpu_sys = cpu.sys;
+    p.cpu_usr = cpu.user;
+    p.cpu_irq = cpu.irq;
+    p.cpu_proc = cpu.proc;
+
+    p.disk = ResourceProfile.getDisk().usage;
+
+    if(p.version <= 1) p.mem = ResourceProfile.getMemory().usage;
+    else p.mem = ResourceProfile.getMemoryV2().usage;
+
+    p.cpu_cores = cpu.core;
+    p.host_ip = SecurityMaster.IP;
+    p.pid=process.pid;
+    
+    if (KubeUtil.container_id != null) {
+        p.mem = 0;
+        p.cpu = 0;
+    }
+};
+
+module.exports = SystemPerf;

package/lib/data/datapack-sender.js

@@ -0,0 +1,289 @@
+/**
+ * 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 conf            = require('../conf/configure'),
+    secuMaster      = require('../net/security-master'),
+    TcpRequestMgr   = require('../net/tcprequest-mgr'),
+    NetFlag         = require('../net/netflag').NetFlag,
+    ParamDef        = require('../net/paramdef'),
+    DateUtil        = require('./../util/dateutil'),
+    Long            = require('long');
+
+var sendPack = function(p){
+    if (p == null)
+        return;
+
+    p.pcode = secuMaster.PCODE;
+    p.oid = secuMaster.OID;
+    p.okind=secuMaster.OKIND;
+    p.onode=secuMaster.ONODE;
+    
+    switch (conf.encrypt_level || 2) {
+        case 1:
+            TcpRequestMgr.add(0, p);
+            break;
+        case 2:
+            TcpRequestMgr.add(NetFlag.SECURE_HIDE, p);
+            break;
+        case 3:
+        default:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+    }
+};
+
+var sendCounterPack = function(p){
+    return sendPack(p);
+};
+
+var sendTagCounterPack = function(p){
+    if (p == null) return;
+
+    p.pcode = secuMaster.PCODE;
+    p.oid = secuMaster.OID;
+    p.putTagString("oname", secuMaster.ONAME);
+    // p.okind=secuMaster.OKIND;
+    // p.onode=secuMaster.ONODE;
+
+    if(conf.OKIND){
+        p.okind = conf.OKIND;
+        p.putTagString("okindName", conf.OKIND_NAME);
+    }
+    if(conf.ONODE){
+        p.okind = conf.ONODE;
+        p.putTagString("onodeName", conf.ONODE_NAME);
+    }
+
+    switch (conf.encrypt_level || 2) {
+        case 1:
+            TcpRequestMgr.add(0, p);
+            break;
+        case 2:
+            TcpRequestMgr.add(NetFlag.SECURE_HIDE, p);
+            break;
+        case 3:
+        default:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+    }
+};
+
+var sendHitMapPack1 = function(p){
+    return sendPack(p);
+};
+
+var sendActiveStackPack = function(p){
+    p.pcode = secuMaster.PCODE;
+    p.oid = secuMaster.OID;
+    p.okind=secuMaster.OKIND;
+    p.onode=secuMaster.ONODE;
+
+    var enc_level = conf.encrypt_level || 2;
+    switch (enc_level) {
+        case 1:
+            TcpRequestMgr.addProfile(0, p);
+            break;
+        case 2:
+            TcpRequestMgr.addProfile(NetFlag.SECURE_HIDE, p);
+            break;
+        case 3:
+        default:
+            TcpRequestMgr.addProfile(NetFlag.SECURE_CYPHER, p);
+            break;
+    }
+};
+
+var sendTextPack = function(p){
+    p.pcode = secuMaster.PCODE;
+    p.oid = secuMaster.OID;
+    p.okind=secuMaster.OKIND;
+    p.onode=secuMaster.ONODE;
+
+    p.time = Long.fromNumber(DateUtil.currentTime());
+
+    var enc_level = conf.encrypt_level || 2;
+
+    switch (enc_level) {
+        case 1:
+            TcpRequestMgr.add(NetFlag.SECURE_HIDE, p);
+            break;
+        case 2:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+        case 3:
+        default:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+    }
+};
+
+var sendErrorSnapPack = function(p){
+    return sendPack(p);
+};
+
+var sendProfilePack = function(p){
+
+    p.pcode = secuMaster.PCODE ;
+    p.oid = secuMaster.OID;
+    p.okind=secuMaster.OKIND;
+    p.onode=secuMaster.ONODE;
+
+    var enc_level = conf.encrypt_level || 2;
+    switch(enc_level) {
+        case 1:
+            break;
+        case 2:
+            TcpRequestMgr.addProfile(NetFlag.SECURE_CYPHER, p);
+            break;
+        case 3:
+        default:
+            TcpRequestMgr.addProfile(NetFlag.SECURE_CYPHER, p);
+            break;
+    }
+};
+
+var sendStatServicePack = function (p) {
+    return sendPack(p);
+};
+
+var sendStatSqlPack = function(p){
+    return sendPack(p);
+};
+
+var sendStatHttpcPack = function(p){
+    return sendPack(p);
+};
+
+var sendStatErrorPack = function(p){
+    return sendPack(p);
+};
+
+var sendRealtimeUserPack = function(p){
+    return sendPack(p);
+};
+
+var sendStatRemoteIpPack = function(p){
+    return sendPack(p);
+};
+
+var sendStatRemoteIpUrlPack = function(p){
+    return sendPack(p);
+};
+
+var sendStatUserAgentPack = function(p){
+    return sendPack(p);
+};
+
+var sendLogSinkPack = function(p){
+    if (p == null)
+        return;
+
+    p.pcode = secuMaster.PCODE;
+    p.oid = secuMaster.OID;
+    p.okind=secuMaster.OKIND;
+    p.onode=secuMaster.ONODE;
+
+    if (conf.getProperty('logsink_high_secure_enabled', false)) {
+        TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+    }else{
+        TcpRequestMgr.add(NetFlag.SECURE_HIDE, p);
+    }
+};
+
+var sendEventPack = function(p){
+    return sendPack(p);
+};
+
+var sendBoot = function(p){
+    p.id = ParamDef.AGENT_BOOT_ENV;
+    p.pcode = secuMaster.PCODE;
+    p.oid = secuMaster.OID;
+    p.okind=secuMaster.OKIND;
+    p.onode=secuMaster.ONODE;
+    p.time = Long.fromNumber(DateUtil.currentTime());
+
+    var enc_level = conf.encrypt_level || 2;
+    switch (enc_level) {
+        case 1:
+            TcpRequestMgr.add(NetFlag.SECURE_HIDE, p);
+            break;
+        case 2:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+        case 3:
+        default:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+    }
+};
+
+var sendResponse = function(p){
+    p.pcode = secuMaster.PCODE;
+    p.oid = secuMaster.OID;
+    p.okind=secuMaster.OKIND;
+    p.onode=secuMaster.ONODE;
+
+    switch (conf.encrypt_level) {
+        case 1:
+            TcpRequestMgr.add(NetFlag.SECURE_HIDE, p);
+            break;
+        case 2:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+        case 3:
+        default:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+    }
+};
+
+var sendResponseHide = function(p){
+    p.pcode = secuMaster.PCODE;
+    p.oid = secuMaster.OID;
+    p.okind=secuMaster.OKIND;
+    p.onode=secuMaster.ONODE;
+
+    switch (conf.encrypt_level) {
+        case 1:
+            TcpRequestMgr.add(NetFlag.SECURE_HIDE, p);
+            break;
+        case 2:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+        case 3:
+        default:
+            TcpRequestMgr.add(NetFlag.SECURE_CYPHER, p);
+            break;
+    }
+};
+
+var DataPackSender = {
+    sendPack                : sendPack,
+    sendCounterPack         : sendCounterPack,
+    sendHitMapPack1         : sendHitMapPack1,
+    sendActiveStackPack     : sendActiveStackPack,
+    sendTextPack            : sendTextPack,
+    sendErrorSnapPack       : sendErrorSnapPack,
+    sendProfilePack         : sendProfilePack,
+    sendTagCounterPack      : sendTagCounterPack,
+
+    sendStatServicePack     : sendStatServicePack,
+    sendStatSqlPack         : sendStatSqlPack,
+    sendStatHttpcPack       : sendStatHttpcPack,
+    sendStatErrorPack       : sendStatErrorPack,
+    sendStatRemoteIpPack    : sendStatRemoteIpPack,
+    sendStatRemoteIpUrlPack : sendStatRemoteIpUrlPack,
+    sendStatUserAgentPack   : sendStatUserAgentPack,
+    sendLogSinkPack         : sendLogSinkPack,
+
+    sendRealtimeUserPack    : sendRealtimeUserPack,
+    sendEventPack           : sendEventPack,
+    sendBoot                : sendBoot,
+    sendResponse            : sendResponse,
+    sendResponseHide        : sendResponseHide
+}
+
+module.exports = DataPackSender;

package/lib/data/dataprofile-agent.js

@@ -0,0 +1,162 @@
+/**
+ * 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 DataPackSender  = require('./datapack-sender'),
+    StatTranX       = require('../stat/stat-tranx'),
+    StatRemoteIp    = require('../stat/stat-remote-ip'),
+    StatUserAgent   = require('../stat/stat-useragent'),
+    StatTranxDomain   = require('../stat/stat-tx-domain'),
+    StatTranxMtCaller   = require('../stat/stat-tx-caller'),
+    StatTranxReferer   = require('../stat/stat-tx-referer'),
+    StatRemoteIpUrl   = require('../stat/stat-remote-ipurl'),
+    conf            = require('../conf/configure'),
+    HashUtil            = require('../util/hashutil'),
+    EventLevel          = require('../data/event-level'),
+    DataTextAgent       = require('../data/datatext-agent'),
+    Long = require('long'),
+    Logger          = require('../logger');
+
+var ZipProfile = require('./zipprofile');
+var profile_zip_enabled = conf.getProperty('profile_zip_enabled', false);
+var stat_ipurl_enabled = conf.getProperty('stat_ipurl_enabled', false);
+conf.on('profile_zip_enabled', function(newProperty) {
+    profile_zip_enabled = newProperty;
+});
+conf.on('stat_ipurl_enabled', function(newProperty) {
+    stat_ipurl_enabled = newProperty;
+});
+
+var DataProfileAgent = {
+    last_reject : 0,
+    sendProfile : function (ctx, profile, rejected) {
+        try {
+            StatRemoteIp.incRemoteIp(ctx.remoteIp);
+            StatUserAgent.incUserAgent(ctx.userAgent);
+
+            var transaction = profile.service;
+            if(stat_ipurl_enabled && ctx.remoteIp){
+                var tc = StatRemoteIpUrl.getService(ctx.remoteIp, ctx.service_hash);
+                if (tc) {
+                    tc.count++;
+                    if (tc.errorLevel >= EventLevel.WARNING) {
+                        tc.error++;
+                    }
+                    tc.time += transaction.elapsed;
+                }
+            }
+
+            if(conf.stat_domain_enabled && ctx.http_host_hash!=0) {
+                StatTranxDomain.add(ctx.http_host_hash, ctx.service_hash, transaction.elapsed, ctx.error != 0);
+            }
+
+            if(conf.trace_referer_enabled && ctx.referer!=0) {
+                StatTranxReferer.add(ctx.referer, ctx.service_hash, transaction.elapsed, ctx.error != 0);
+            }
+
+            if(conf.stat_mtrace_enabled && ctx.mcaller_pcode!=0) {
+                var key = StatTranxMtCaller.getService(ctx.mcaller_pcode, ctx.mcaller_okind, ctx.mcaller_spec, ctx.mcaller_url,ctx.service_hash);
+                transaction.mthis_spec = conf.mtrace_spec_hash
+
+                if (ctx.mcaller_spec && ctx.mcaller_spec!='') {
+                    transaction.mcaller_spec = key.mcaller_spec = HashUtil.hashFromString(ctx.mcaller_spec);
+                    DataTextAgent.MTRACE_SPEC.add(transaction.mcaller_spec, ctx.mcaller_spec);
+                }
+                if (ctx.mcaller_url  && ctx.mcaller_url!='') {
+                    transaction.mcaller_url = key.mcaller_url = HashUtil.hashFromString(ctx.mcaller_url);
+                    DataTextAgent.MTRACE_CALLER_URL.add(transaction.mcaller_url, ctx.mcaller_url);
+                }
+
+                // additional multi transaction
+                //key.url = ctx.service_hash;
+                var tc = StatTranxMtCaller.getService(key);
+                if (tc != null) {
+                    tc.count++;
+                    if (transaction.errorLevel >= EventLevel.WARNING) {
+                        tc.error++;
+                    }
+                    tc.time += transaction.elapsed;
+                }
+
+                // StatTranxMtCaller.add(ctx.mcaller_pcode,
+                //      ctx.mcaller_okind,
+                //      transaction.mcaller_spec,
+                //      transaction.mcaller_url,
+                //      ctx.service_hash,
+                //      transaction.elapsed,
+                //      ctx.error != 0);
+            }
+
+            var stat = StatTranX.getService(transaction.service);
+
+            if(stat !== null) {
+                stat.count++;
+                if(transaction.error.isZero() ==false) {
+                    stat.error++;
+                }
+                if(transaction.elapsed < 0) {
+                    transaction.elapsed = 0;
+                }
+
+                stat.actived += ctx.profileActive;
+                stat.time_sum += transaction.elapsed;
+                if (transaction.elapsed > stat.time_max) {
+                    stat.time_max = transaction.elapsed;
+                }
+
+                switch (transaction.apdex) {
+                    case 2:
+                        stat.apdex_satisfied++;
+                        break;
+                    case 1:
+                        stat.apdex_tolerated++;
+                        break;
+                }
+                if (stat.time_min==0 || transaction.elapsed < stat.time_min) {
+                    stat.time_min = transaction.elapsed;
+                }
+                stat.time_std += (Long.fromInt(transaction.elapsed) * Long.fromInt(transaction.elapsed));
+
+                stat.sql_count += transaction.sqlCount;
+                stat.sql_time +=transaction.sqlTime;
+                stat.sql_fetch += ctx.rs_count;
+                stat.sql_fetch_time +=ctx.rs_time;
+
+                stat.httpc_count += transaction.httpcCount;
+                stat.httpc_time +=transaction.httpcTime;
+
+                stat.malloc_sum +=transaction.malloc;
+                stat.cpu_sum +=transaction.cpuTime;
+
+                if (rejected) {
+                    var now = Date.now();
+                    if (now < this.last_reject + 1000) {
+                        return;
+                    }
+                    this.last_reject = now;
+                } else if (stat.profiled == true    // 이전(5분구간 내)에 프로파일이 수집된점이 있음
+                    && ctx.profileActive == 0       // 액티브 스택을 추적한적이 없음
+                    && transaction.elapsed < conf.profile_basetime
+                    && transaction.error.isZero()) {
+                    return;
+                }
+                stat.profiled = true;
+            }
+
+            var steps = ctx.profile.getSteps();
+            profile.setProfile(steps);
+            if(profile_zip_enabled){
+                ZipProfile.getInstance().add(profile);
+            } else {
+                DataPackSender.sendProfilePack(profile);
+            }
+
+        } catch(e) {
+            Logger.printError('WHATAP-199', 'dataprofile-agent error', e);
+        }
+    }
+};
+
+module.exports = DataProfileAgent;

package/lib/data/datatext-agent.js

@@ -0,0 +1,135 @@
+/**
+ * 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 RequestQueue    = require('../util/request-queue'),
+    TextPack        = require('../pack/text-pack').TextPack,
+    TextRec         = require('../pack/text-pack').TextRec,
+    TextTypes       = require('../lang/text-types'),
+    DataPackSender  = require('../data/datapack-sender'),
+    DateUtil        = require('../util/dateutil'),
+    IntSet        = require('../util/intset');
+
+const BUFFERD_MAX   = 10 * 1024;
+const INTERVAL      = 500;   // 제어 가능해야 한다.
+
+const DBC               = new HashedData(TextTypes.DB_URL, 1000);
+const METHOD            = new HashedData(TextTypes.METHOD, 5000);
+const HTTPC_URL         = new HashedData(TextTypes.HTTPC_URL, 2000);
+const HTTPC_HOST        = new HashedData(TextTypes.HTTPC_HOST, 2000);
+const ERROR             = new HashedData(TextTypes.ERROR, 1000);
+const SERVICE           = new HashedData(TextTypes.SERVICE, 2000);
+const SQL               = new HashedData(TextTypes.SQL, 2000);
+const STACK             = new HashedData(TextTypes.STACK_ELEMENTS, 20000);
+const MESSAGE           = new HashedData(TextTypes.MESSAGE, 2000);
+const USERAGENT         = new HashedData(TextTypes.USER_AGENT, 1000);
+const USER_AGENT_OS     = new HashedData(TextTypes.USER_AGENT_OS, 1000);
+const USER_AGENT_BROWSER= new HashedData(TextTypes.USER_AGENT_BROWSER, 1000);
+const REFERER           = new HashedData(TextTypes.REFERER, 1000);
+const HTTP_DOMAIN       = new HashedData(TextTypes.HTTP_DOMAIN, 500);
+const MTRACE_SPEC       = new HashedData(TextTypes.MTRACE_SPEC, 500);
+const MTRACE_CALLER_URL       = new HashedData(TextTypes.MTRACE_CALLER_URL, 500);
+const OKIND       = new HashedData(TextTypes.OKIND_NAME, 100);
+const ONODE       = new HashedData(TextTypes.ONODE_NAME, 100);
+
+var DataTextAgent = function () {
+
+    if(typeof DataTextAgent.instance == 'object') {
+        return DataTextAgent.instance;
+    }
+
+    this.date = DateUtil.yyyymmddhh();
+    this.queue = new RequestQueue(500);
+    this.bufferPack = new TextPack();
+    this.bufferedLength = 0;
+    this.run();
+
+    DataTextAgent.instance = this;
+};
+
+DataTextAgent.prototype.run = function () {
+    var r = this.queue.get();
+    if(r !== null) {
+        this.bufferPack.records.push(r);
+        this.bufferedLength += r.text.length;
+        if(this.bufferedLength >= BUFFERD_MAX) {
+            this.send();
+        }
+    } else {
+        if(this.bufferedLength > 0) {
+            this.send();
+        }
+    }
+
+    if(this.date !== DateUtil.yyyymmddhh()) {
+        this.reset();
+        this.date = DateUtil.yyyymmddhh();
+    }
+
+    var self = this;
+    setTimeout(function () {
+        self.run();
+    }, INTERVAL, 'whatap');
+};
+DataTextAgent.prototype.add = function (type, hash, text) {
+    this.queue.put(new TextRec(type, hash, text));
+};
+DataTextAgent.prototype.send = function () {
+    DataPackSender.sendTextPack(this.bufferPack);
+    this.bufferPack = new TextPack();
+    this.bufferedLength = 0;
+};
+DataTextAgent.prototype.reset = function () {
+    DBC.sent.clear();
+    METHOD.sent.clear();
+    HTTPC_URL.sent.clear();
+    HTTPC_HOST.sent.clear();
+    ERROR.sent.clear();
+    SERVICE.sent.clear();
+    SQL.sent.clear();
+    STACK.sent.clear();
+    MESSAGE.sent.clear();
+    USERAGENT.sent.clear();
+    USER_AGENT_OS.sent.clear();
+    USER_AGENT_BROWSER.sent.clear();
+    REFERER.sent.clear();
+    HTTP_DOMAIN.sent.clear();
+    MTRACE_SPEC.sent.clear();
+    MTRACE_CALLER_URL.sent.clear();
+    OKIND.sent.clear();
+    ONODE.sent.clear();
+};
+
+function HashedData(type, n) {
+    this.type = type || 0;
+    this.sent = new IntSet().setMax(n);
+}
+HashedData.prototype.add = function (hash, text) {
+    if(require('../trace/trace-context-manager').initialized === false) { return; }
+    // 보내지 않은 Hash인 경우 추가
+    if(this.sent.hasKey(hash) == false) {
+        this.sent.add(hash);
+        new DataTextAgent().add(this.type, hash, text);
+    }
+};
+
+exports.agent = new DataTextAgent();
+exports.DBC = DBC;
+exports.METHOD = METHOD;
+exports.HTTPC_URL = HTTPC_URL;
+exports.HTTPC_HOST = HTTPC_HOST;
+exports.ERROR = ERROR;
+exports.SERVICE = SERVICE;
+exports.SQL = SQL;
+exports.STACK = STACK;
+exports.MESSAGE = MESSAGE;
+exports.USERAGENT = USERAGENT;
+exports.USER_AGENT_OS = USER_AGENT_OS;
+exports.USER_AGENT_BROWSER = USER_AGENT_BROWSER;
+exports.REFERER = REFERER;
+exports.HTTP_DOMAIN = HTTP_DOMAIN;
+exports.MTRACE_SPEC = MTRACE_SPEC;
+exports.MTRACE_CALLER_URL = MTRACE_CALLER_URL;
+exports.OKIND = OKIND;
+exports.ONODE = ONODE;

package/lib/data/event-level.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.
+ */
+
+var EventLevel = {
+    FATAL: Buffer.alloc(30),
+    WARNING: Buffer.alloc(20),
+    INFO: Buffer.alloc(10),
+    NONE: Buffer.alloc(0)
+}
+
+module.exports = EventLevel;
+

package/lib/data/test.js

@@ -0,0 +1,49 @@
+var IntSet  = require('../util/intset') ,
+TagCountPack = require('../pack/tagcount-pack');
+const DataPackSender = require('./datapack-sender');
+
+var Test = function() {
+    this.sent = new IntSet().setMax(10);
+    this.init()
+}
+
+Test.prototype.init = function() {
+    this.sent.add(1);
+    this.sent.add(2);
+    this.sent.add(3);
+    this.sent.add(4);
+    this.sent.add(5);
+    this.sent.add(6);
+    this.sent.add(7);
+    this.sent.add(8);
+    this.sent.add(9);
+    this.sent.add(10);
+    this.sent.add(11);
+    this.sent.add(12);
+    this.sent.add(13);
+    this.sent.add(14);
+    if(this.sent.hasKey(14) == false) {
+        console.log(this.sent.getLastValue())
+        this.sent.add(15);
+    }
+    var p = new TagCountPack()
+    p.category = 'aaaa' 
+    p.pcode = 101
+    p.oid = 1
+    p.putTagString('tag1','tag1')
+    p.putTagString('tag2','tag2')
+    p.putTagString('tag3','tag3')
+    p.putTagString('tag4','tag4')
+    p.putTagString('tag5','tag5')
+    p.putTagString('tag6','tag6')
+    p.putInt('filed1' , 100)
+    p.putInt('filed2' , 200)
+    p.putInt('filed3' , 300)
+    p.putInt('filed4' , 400)
+    p.putInt('filed5' , 500)
+    p.putInt('filed6' , 600)
+    
+    DataPackSender.sendTagCounterPack(p);
+}
+
+exports.Test = new Test();