whatap 1.0.1 → 1.0.2

package/lib/topology/nodeinfo.js

@@ -0,0 +1,123 @@
+const DataOutputX = require('../io/data-outputx');
+const DataInputX = require('../io/data-inputx');
+const MapValue = require('../value/map-value');
+const LINK = require('./link');
+const net = require('net');
+
+function NodeInfo() {
+    this.attr = new MapValue();
+    this.listen = new Set();
+    this.outter = new Set();
+
+    this.addListen = function (localIPs, address) {
+        const ipo = this.getIPPORT(address);
+        if (!ipo || this.isLocal127(ipo)) return;
+
+        if (ipo.ip === '*' || ipo.ip === '0.0.0.0' || ipo.ip === '::') {
+            localIPs.forEach(local_ip => {
+                const k = LINK.create(local_ip, parseInt(ipo.port, 10));
+                if (k) this.listen.add(k);
+            });
+        } else {
+            const k = LINK.create(ipo.ip, parseInt(ipo.port, 10));
+            if (k) this.listen.add(k);
+        }
+    };
+
+    this.addOutter = function (local, remote) {
+        const localIPO = this.getIPPORT(local);
+        if (!localIPO || this.isIPv6(localIPO)) return;
+        if (this.hasListen(localIPO.ip, localIPO.port)) return;
+
+        const remoteIPO = this.getIPPORT(remote);
+        if (!remoteIPO || this.isIPv6(remoteIPO) || this.isLocal127(remoteIPO)) return;
+
+        const k = LINK.create(remoteIPO.ip, parseInt(remoteIPO.port, 10));
+        if (k) this.outter.add(k);
+    };
+
+    this.hasListen = function (ip, port) {
+        const k = LINK.create(ip, parseInt(port, 10));
+        return this.listen.has(k);
+    };
+
+    this.getIPPORT = function (address) {
+        try {
+            const ipo = {};
+            const x = address.lastIndexOf(':');
+            ipo.ip = address.substring(0, x);
+            ipo.port = address.substring(x + 1);
+            return ipo;
+        } catch (e) {
+            return null;
+        }
+    };
+
+    this.toBytes = function () {
+        const out = new DataOutputX();
+        out.writeByte(0);
+        out.writeValue(this.attr);
+        this.toLinkBytes(this.listen, out);
+        this.toLinkBytes(this.outter, out);
+        return out.toByteArray();
+    };
+
+    this.toObject = function (b) {
+        const din = new DataInputX(b);
+        const ver = din.readByte();
+        this.attr = din.readValue();
+        this.listen = this.toLinkObject(din);
+        this.outter = this.toLinkObject(din);
+        return this;
+    };
+
+    this.toLinkObject = function (din) {
+        const data = new Set();
+        const sz = din.readDecimal();
+        for (let i = 0; i < sz; i++) {
+            data.add(new LINK().toObject(din));
+        }
+        return data;
+    };
+
+    this.toLinkBytes = function (data, out) {
+        out.writeDecimal(data.size);
+        if (data.size === 0) return;
+        data.forEach(k => k.toBytes(out));
+    };
+
+    this.toJSON = function () {
+        const o = new Map();
+        o.put('attr', JSON.stringify(this.attr));
+        o.put('listen', JSON.parse(this.listen));
+        o.put('outter', JSON.parse(this.outter));
+        return o;
+    };
+
+    this.toJSON = function (data) {
+        const out = new JSONArray();
+        data.forEach(k => out.put(k.toString()));
+        return out;
+    };
+
+    this.isIPv6 = function(data) {
+        var ip = data.ip;
+        if(ip){
+            return net.isIPv6(ip);
+        }
+        return false;
+    };
+
+    this.isLocal127 = function (data) {
+        var ip = data.ip;
+        if(ip){
+            return ip === '127.0.0.1';
+        }
+        return false;
+    }
+}
+
+NodeInfo.prototype = new NodeInfo();
+NodeInfo.prototype.constructor = NodeInfo;
+
+module.exports = NodeInfo;

package/lib/topology/status-detector.js

@@ -0,0 +1,111 @@
+var { exec } = require('child_process');
+var os = require('os');
+var NodeInfo = require('./nodeinfo');
+var Logger = require('../logger');
+
+function StatusDetector() {
+    this.process = async function () {
+        let node = new NodeInfo();
+        let stat = await this.netstat();
+
+        if (!stat) {
+            node = new NodeInfo();
+        } else {
+            try {
+                node = this.parse(stat);
+            } catch (e) {
+                node = new NodeInfo();
+                Logger.printError("WHATAP-203", "NodeInfo parse error", e, false);
+            }
+        }
+
+        node.attr.type = 'nodejs';
+        node.attr.time = Date.now();
+        node.attr.ip = this.getLocalIpAddress();
+        node.attr.pid = process.pid;
+        node.attr.pname = process.title;
+
+        return node;
+    };
+
+    this.netstat = function () {
+        return new Promise((resolve, reject) => {
+            let cmd = 'netstat -an -t';
+            if (os.platform() === 'darwin') {
+                cmd = 'netstat -an -p tcp';
+            } else if (os.platform() === 'win32') {
+                resolve('');
+                return;
+            }
+
+            exec(cmd, (error, stdout, stderr) => {
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(stdout);
+            });
+        });
+    };
+
+    this.parse = function (netstat) {
+        var node = new NodeInfo();
+        var localIPs = this.getLocalIpSet();
+
+        var lines = netstat.split('\n');
+        lines.forEach(line => {
+            if (line.startsWith('tcp')) {
+                this.parseLine(node, line, localIPs);
+            }
+        });
+
+        return node;
+    };
+
+    this.parseLine = function (node, line, localIPs) {
+        var tokens = line.trim().split(/\s+/);
+        if (!tokens[0].startsWith('tcp')) return;
+
+        var localAddress = tokens[3].replace(/(\d+\.\d+\.\d+\.\d+)\.(\d+)/, '$1:$2');
+        var remoteAddress = tokens[4].replace(/(\d+\.\d+\.\d+\.\d+)\.(\d+)/, '$1:$2');
+
+        if (tokens[5] === 'LISTEN') {
+            node.addListen(localIPs, localAddress);
+        } else {
+            node.addOutter(localAddress, remoteAddress);
+        }
+    };
+
+    this.getLocalIpSet = function () {
+        var ipSet = new Set();
+        var interfaces = os.networkInterfaces();
+        for (var devName in interfaces) {
+            var iface = interfaces[devName];
+            iface.forEach(alias => {
+                if (alias.family === 'IPv4' && !alias.internal) {
+                    ipSet.add(alias.address);
+                }
+            });
+        }
+        return ipSet;
+    };
+
+    this.getLocalIpAddress = function () {
+        var interfaces = os.networkInterfaces();
+        for (var devName in interfaces) {
+            var iface = interfaces[devName];
+            for (let i = 0; i < iface.length; i++) {
+                var alias = iface[i];
+                if (alias.family === 'IPv4' && !alias.internal) {
+                    return alias.address;
+                }
+            }
+        }
+        return '0.0.0.0';
+    };
+}
+
+StatusDetector.prototype = new StatusDetector();
+StatusDetector.prototype.constructor = StatusDetector;
+
+module.exports = StatusDetector;

package/lib/trace/trace-context-manager.js

@@ -7,12 +7,11 @@
 var IntKeyMap       = require('../util/intkey-map'),
     HashUtil        = require('../util/hashutil'),
     TraceContext    = require('./trace-context'),
-    Logger          = require('../logger');
-var Long            = require('long');
+    Logger          = require('../logger'),
+    EventLevel      = require('../data/event-level');
+Long            = require('long');
 var { AsyncLocalStorage } = require('async_hooks');
 var crypto = require('crypto');
-var { v1: uuidv1 } = require('uuid');
-const KeyGen = require('../util/keygen');
 
 function TraceContextManager() {
     this.initialized = false;
@@ -20,8 +19,6 @@ function TraceContextManager() {
     this.currentId = null;
     this._asyncLocalStorage = new AsyncLocalStorage();
     this.entry = new IntKeyMap(1021,1).setMax(5000);
-    this.node = null;
-    this.clock_seq = null;
 }
 
 TraceContextManager.prototype.keys = function () {
@@ -34,10 +31,14 @@ TraceContextManager.prototype.size = function () {
     return this.entry.size();
 };
 TraceContextManager.prototype.getContext = function (key) {
+    // if(key == null ) {
+    //     return null;
+    // }
+    // return this.entry.get(key);
     return this._asyncLocalStorage.getStore();
 };
 TraceContextManager.prototype.getCurrentContext = function () {
-    return this.getContext();
+    return this.getContext(this.currentId);
 };
 TraceContextManager.prototype.start = function () {
 
@@ -46,10 +47,10 @@ TraceContextManager.prototype.start = function () {
     // var conf = require('../conf/configure');
     // if(this.size() > conf.profile_max_count) { return null; }
 
-    var ctx = new TraceContext(KeyGen.next());
+    var ctx = new TraceContext(this.getNextId());
     ctx.start_time = Date.now();
-    this.entry.put(ctx.id, ctx);
-    this.currentId = ctx.id;
+    this.entry.put(ctx._id, ctx);
+    this.currentId = ctx._id;
 
     return ctx;
 };
@@ -87,32 +88,119 @@ TraceContextManager.prototype.resume = function (id) {
         return null;
     }
 };
+TraceContextManager.prototype.getTxProfile = function(n) {
+    var ctx = this.getCurrentContext();
+    if(ctx == null)
+        return null;
+    return ctx.profile.getLastSteps(n);
+};
 TraceContextManager.prototype.isExist = function (id) {
     return this.entry.containsKey(id);
 };
+var DataTextAgent = require('../data/datatext-agent');
+var MessageStep = require('../step/message-step');
+TraceContextManager.prototype.addStep = function (title, desc, ctx) {
+    // var ctx = this.getCurrentContext();
+    if(ctx == null) {
+        return null;
+    }
+    try {
+        var step = new MessageStep();
+        step.start_time = ctx.getElapsedTime();
+        step.hash = HashUtil.hashFromString(title);
+        DataTextAgent.MESSAGE.add(step.hash, title);
+        step.desc = desc;
+        step.ctx = ctx;
+        ctx.profile.push(step);
+        return step;
+    } catch(e) {
+        return null;
+    }
+};
+TraceContextManager.prototype.endStep = function (step) {
+    if(step == null || step.ctx == null) {
+        return;
+    }
+    this.resume(step.ctx);
+    step.time = step.ctx.getElapsedTime() - step.start_time;
+};
+
+TraceContextManager.prototype.startTrace = function (title) {
+    try{
+        var ctx = this.start();
+        if(ctx == null) {
+            return null;
+        }
+        ctx.service_name = title;
+        ctx.service_hash = HashUtil.hashFromString(title);
+        var DataTextAgent = require('../data/datatext-agent'),
+            ResourceProfile = require('../util/resourceprofile');
+        DataTextAgent.SERVICE.add(ctx.service_hash, title);
+        ctx.start_cpu = ResourceProfile.getCPUTime();
+        ctx.start_malloc = ResourceProfile.getUsedHeapSize();
 
-TraceContextManager.prototype.getId = function () {
-    if (!this.node) {
-        this.node = Math.floor(Math.random() * 0xffffffffffff);
+        return ctx;
+    }catch(e){
+        Logger.printError('WHATAP-998', 'TraceContext (startTrace)', e, true);
     }
+};
+TraceContextManager.prototype.endTrace = function (ctx) {
+    if(ctx == null) {return;}
+    var ProfilePack = require('../pack/profile-pack'),
+        TxRecord  = require('../service/tx-record'),
+        DateUtil    = require('../util/dateutil'),
+        MeterService = require('../counter/meter/meter-service').MeterService,
+        DataProfileAgent = require('../data/dataprofile-agent'),
+        ResourceProfile = require('../util/resourceprofile'),
+        SecurityMaster = require('../net/security-master');
+
+    var profile = new ProfilePack();
+    var service = new TxRecord();
+    profile.time = Long.fromValue(ctx.start_time);
+    service.endTime = DateUtil.currentTime();
+    service.elapsed = ctx.getElapsedTime();
+    service.service = ctx.service_hash;
+    DataTextAgent.SERVICE.add(ctx.service_hash, ctx.service_name);
 
-    if (!this.clock_seq) {
-        this.clock_seq = Math.floor(Math.random() * (1 << 14));
+    service.cpuTime = ResourceProfile.getCPUTime() - ctx.start_cpu;
+    service.malloc = ResourceProfile.getUsedHeapSize() - ctx.start_malloc;
+    if(service.malloc < 0) { service.malloc = 0; }
+    service.seq = ctx.txid;
+    service.sqlCount = ctx.sql_count;
+    service.sqlTime = ctx.sql_time;
+    service.sqlFetchCount = ctx.rs_count;
+    service.sqlFetchTime = parseInt(ctx.rs_time);
+    service.ipaddr = ctx.remoteIp;
+    service.userid = ctx.userid;
+
+    service.mcaller_pcode = ctx.mcaller_pcode;
+    service.mcaller_okind = ctx.mcaller_okind;
+    service.mcaller_oid = ctx.mcaller_oid;
+
+    if (ctx.error.isZero()==false/*long*/) {
+        service.error = ctx.error;
+        service.errorLevel = EventLevel.WARNING;
     }
+    service.userAgent = ctx.userAgent;
+    service.referer = ctx.referer;
+
+    service.httpcCount = ctx.httpc_count;
+    service.httpcTime = ctx.httpc_time;
+    service.status = ctx.status;
 
-    const uuid1 = uuidv1({
-        node: this.node,
-        clockseq: this.clock_seq
-    });
+    service.http_method=TxRecord.HTTP_METHOD[ctx.http_method] || TxRecord.WEB_GET;
 
-    const buffer = Buffer.from(uuid1.replace(/-/g, ''), 'hex');
-    const uuidInt = BigInt('0x' + buffer.toString('hex'));
+    MeterService.add(service.service, service.elapsed, service.errorLevel, service.mcaller_pcode, service.mcaller_okind, service.mcaller_oid , service.apdex);
 
-    const upperBits = (uuidInt >> 64n) & 0xffffffffffffffffn;
-    const lowerBits = (uuidInt << 64n) & 0xffffffffffffffffn;
-    const key = upperBits ^ lowerBits;
+    profile.oid = SecurityMaster.OID;
+    profile.service = service;
 
-    return Long.fromString(key.toString()).toNumber();
+    var self = this;
+    setTimeout(function () {
+        DataProfileAgent.sendProfile(ctx, profile, false);
+        self.end(ctx._id);
+        ctx = null;
+    }, 100);
 };
 
 module.exports = new TraceContextManager();

package/lib/trace/trace-context.js

@@ -13,29 +13,39 @@ var ProfileCollector    = require('./profile-collector'),
     Long                = require('long');
 
 function TraceContext(id) {
-    this.id = id;
+    this._id = id;
     this.isStaticContents = false;
     this.profile = new ProfileCollector(this);
 
-    this.pid = process.pid;
-
     this.txid = KeyGen.next();
     this.thread = null;
     this.thread_id = 0;
 
     this.start_cpu = 0;
+    this.start_malloc = 0;
+    this.start_time = 0;
+
     this.status = 0;
 
     this.service_hash = 0;
     this.service_name = '';
     this.remoteIp = 0;
-    this.error = 0;
+    this.error = Long.ZERO;
+    this.error_class = '';
+    this.error_message = '';
 
     this.http_method = '';
     this.http_query = '';
     this.http_content_type = '';
+   
+    this.sql_count = 0;
+    this.sql_time = 0;
 
-    this.host = '';
+    this.sql_insert = 0;
+    this.sql_update = 0;
+    this.sql_delete = 0;
+    this.sql_select = 0;
+    this.sql_others = 0;
 
     this.executed_sqlhash = 0;
     this.active_sqlhash = 0;
@@ -59,6 +69,10 @@ function TraceContext(id) {
     this.lastSqlStep = null; /*SqlStepX*/
     this.profileActive = 0;
 
+    this.jdbc_updated = false;
+    this.jdbc_update_record = 0;
+    this.jdbc_identity = 0;
+    this.jdbc_commit = 0;
     this.resultSql = new IntKeyMap().setMax(11);
 
     this.rs_count = 0;
@@ -66,7 +80,7 @@ function TraceContext(id) {
     this.db_opening = false;
 	this.socket_connecting = false;
 
-    this.mtid= Long.ZERO;
+    this.mtid=Long.ZERO;
     this.mdepth = 0;
     this.mcaller_pcode = 0;
     this.mcaller_okind = 0;
@@ -119,7 +133,7 @@ TraceContext.prototype.setCallerPOID= function (poidStr) {
         this.mcaller_okind = poid.okind;
         this.mcaller_oid = poid.oid;
     } catch (e) {
-        Logger.printError('WHATAP-701', 'TraceContext (setCallerPOID)', e, true);
+        Logger.printError('WHATAP-999', 'TraceContext (setCallerPOID)', e, true);
     }
 };
 module.exports = TraceContext;

package/lib/trace/trace-httpc.js

@@ -1,19 +1,25 @@
-const conf = require('../conf/configure'),
-    AsyncSender = require('../udp/async_sender'),
-    PacketTypeEnum = require('../udp/packet_type_enum');
+const   HttpStepX = require('../step/http-stepx'),
+        conf = require('../conf/configure'),
+        StatError= require('../stat/stat-error'),
+        TextTypes= require("../lang/text-types");
 
 var TraceHttpc = function () {}
-TraceHttpc.prototype.isSlowHttpc = function (ctx) {
-    if(!ctx)
+
+TraceHttpc.prototype.hasHttpStepX = function (buffer) {
+    if (!Array.isArray(buffer)) {
+        return [];
+    }
+
+    return buffer.filter(item => item instanceof HttpStepX);
+}
+
+TraceHttpc.prototype.isSlowHttpc = function (ctx, httpc_step) {
+    if(!ctx.profile.buffer)
         return;
     var profile_error_httpc_time_max = conf.getProperty('profile_error_httpc_time_max', 10000);
 
-    if(ctx.elapsed && (ctx.elapsed > profile_error_httpc_time_max)){
-        if (!ctx.error) ctx.error = 1;
-        ctx.status = 500;
-
-        var errors = ['SlOW_HTTPC', 'SlOW HTTPC'];
-        AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+    if(httpc_step.elapsed && (httpc_step.elapsed > profile_error_httpc_time_max)){
+        httpc_step.error = StatError.addError('SLOW_HTTPC', 'SLOW HTTPC', ctx.service_hash, TextTypes.HTTPC_URL, null);
     }
 }
 

package/lib/trace/trace-sql.js

@@ -1,36 +1,44 @@
-const conf = require('../conf/configure'),
-    AsyncSender = require('../udp/async_sender'),
-    PacketTypeEnum = require('../udp/packet_type_enum');
+const   SqlStepX        = require('../step/sql-stepx'),
+    conf            = require('../conf/configure'),
+    StatError       = require('../stat/stat-error'),
+    TextTypes       = require("../lang/text-types");
 
 var TraceSql = function () {}
 
-TraceSql.prototype.isSlowSQL = function (ctx) {
-    if (!ctx) return;
+TraceSql.prototype.hasSqlStepX = function (buffer) {
+    if (!Array.isArray(buffer)) {
+        return [];
+    }
 
-    var profile_error_sql_time_max = conf.getProperty('profile_error_sql_time_max', 30000);
-    var sql_elapsed = ctx.elapsed || 0;
+    return buffer.filter(item => item instanceof SqlStepX);
+}
 
-    if (sql_elapsed > profile_error_sql_time_max) {
-        if (!ctx.error) ctx.error = 1;
-        ctx.status = 500;
+TraceSql.prototype.isSlowSQL = function (ctx) {
+    if(!ctx.profile.buffer)
+        return;
 
-        var errors = ['SLOW_SQL', 'SLOW SQL'];
-        AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+    var profile_error_sql_time_max = conf.getProperty('profile_error_sql_time_max', 30000);
+    var sqlStepX = this.hasSqlStepX(ctx.profile.buffer);
+    var slow_sql_step = sqlStepX.find(step => step.elapsed > profile_error_sql_time_max);
+    if(slow_sql_step){
+        slow_sql_step.error = StatError.addError('SLOW_SQL', 'SLOW SQL', ctx.service_hash, TextTypes.SQL, null);
+        if(ctx.error.isZero()){
+            ctx.error = slow_sql_step.error;
+        }
     }
     return;
 }
 
-TraceSql.prototype.isTooManyRecords = function (rs_count, ctx) {
-    if (!ctx) return;
+TraceSql.prototype.isTooManyRecords = function (sql_step, rs_count, ctx) {
+    if(!ctx.profile.buffer)
+        return;
 
     var profile_error_sql_fetch_max = conf.getProperty('profile_error_sql_fetch_max', 10000);
-    if (rs_count && rs_count > profile_error_sql_fetch_max) {
-        // Too many records 에러 처리
-        if (!ctx.error) ctx.error = 1;
-        ctx.status = 500;
-
-        var errors = ['TOO_MANY_RECORDS', 'Too many records'];
-        AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+    if(rs_count && rs_count > profile_error_sql_fetch_max){
+        sql_step.error = StatError.addError('TOO_MANY_RECORDS', 'Too many records', ctx.service_hash, TextTypes.SQL, null)
+        if(ctx.error.isZero()){
+            ctx.error = sql_step.error;
+        }
     }
 }