whatap 1.0.1 → 1.0.2

package/lib/conf/license.js

@@ -26,7 +26,7 @@ License.getKey = function(lic){
         key.security_key = dInX.readBlob();
         return key;
     } catch(e) {
-        Logger.printError('WHATAP-303', 'License Error', e);
+        Logger.printError('WHATAP-190', 'License Error', e);
     }
     return null;
 };

package/lib/control/cmd-config.js

@@ -0,0 +1,24 @@
+/**
+ * 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 Configure = require('./../conf/configure');
+var MapValue = require('./../value/map-value');
+var PropertyUtil = require('./../util/property-util');
+
+module.exports = {
+    update: function(m /* MapValue */){
+
+    },
+    readConfig: function(){
+        var props = Configure.getCustomProps();
+        var mv = new MapValue();
+        for(var k in props){
+            mv.putString(k, props[k]);
+        }
+        return mv;
+    }
+}

package/lib/control/control-handler.js

@@ -0,0 +1,367 @@
+/**
+ * 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 os = require('os');
+var PackageCtrHelper = require('./packagectr-helper'),
+    RequestQueue = require('../util/request-queue'),
+    PackEnum = require('../pack/packenum'),
+    ParamDef = require('../net/paramdef'),
+    Configure = require('../conf/configure'),
+    MapValue = require('../value/map-value'),
+    DateUtil = require('../util/dateutil'),
+    TextValue = require('../value/text-value'),
+    ResourceProfile = require('../util/resourceprofile'),
+    TraceContextManager = require('../trace/trace-context-manager'),
+    Logger = require('../logger'),
+    StatusDetector = require('../topology/status-detector'),
+    BlobValue = require('../value/blob-value'),
+    conf = require('../conf/configure');
+
+var ControlHandler = function () {
+    this.queue = new RequestQueue(100);
+    this._dataPackSender = null;
+}
+
+ControlHandler.prototype.add = function (p /* Pack */) {
+    this.process(p);
+};
+
+ControlHandler.prototype.process = async function (p) {
+    switch (p.getPackType()) {
+        case PackEnum.PARAMETER:
+            await this.handle(p);
+            break;
+        default:
+            Logger.printError('WHATAP-203', 'Unknown pack received ' + p, new Error('Unknown pack'));
+    }
+};
+
+ControlHandler.prototype.handle = async function (p) {
+    var self = this;
+    if (!this._dataPackSender) {
+        this._dataPackSender = require('../data/datapack-sender');
+    }
+    switch (p.id) {
+        case ParamDef.CONFIGURE_GET:
+            var m = Configure.readCustomConfig();
+            p.setMapValue(m);
+            self._dataPackSender.sendResponseHide(p.getResponse());
+            break;
+        case ParamDef.GET_ACTIVE_STACK:
+            break;
+        case ParamDef.GET_ACTIVE_TRANSACTION_DETAIL:
+            try {
+                var threadId = p.getNumber("thread_id");
+                var profile = p.getLong("profile");
+                var m = getCurrentStackDetail(threadId, profile);
+                p.putValue("detail", m);
+
+                self._dataPackSender.sendResponseHide(p.getResponse());
+            } catch (e) {
+                Logger.printError('WHATAP-010', 'Active Transaction Detail', e, true);
+            }
+            break;
+        case ParamDef.GET_ACTIVE_TRANSACTION_LIST:
+            try {
+                var m = getActiveTxList();
+                p.putValue("active", m);
+                self._dataPackSender.sendResponseHide(p.getResponse());
+            } catch (e) {
+                Logger.printError('WHATAP-203', 'Get active transaction list ', e, true);
+            }
+            break;
+        case ParamDef.HEAP_HISTO:
+
+            break;
+        case ParamDef.LOADED_CLASS_LIST:
+            try {
+                var packageList = PackageCtrHelper.getLoadedPackageList();
+                var mv = new MapValue();
+                var indexLv = mv.newList("index");
+                var nameLv = mv.newList("name");
+                var typeLv = mv.newList("type");
+                var superClassLv = mv.newList("superClass");
+                var interfacesLv = mv.newList("interfaces");
+                var resourceLv = mv.newList("resource");
+
+                for (var i = 0; i < packageList.length; i++) {
+                    var pkg = packageList[i];
+                    indexLv.addLong(i);
+                    nameLv.addString(pkg);
+                    typeLv.addString(pkg);
+                    superClassLv.addString(pkg);
+                    interfacesLv.addString(pkg);
+                    resourceLv.addString(pkg);
+                }
+                p.putValue("classlist", mv);
+            } catch (e) {
+                p.put("error", e.toString());
+            }
+            self._dataPackSender.sendResponseHide(p.getResponse());
+            break;
+
+        case ParamDef.LOADED_CLASS_DETAIL:
+            var pkgName = p.getText("classname");
+            try {
+                var dependencies = PackageCtrHelper.getPackageDetail(pkgName);
+                var subPkgNameAndVersion = '';
+                for (var k in dependencies) {
+                    var dep = dependencies[k];
+                    subPkgNameAndVersion += k + ": " + dep + "\n";
+                }
+                p.put("class", subPkgNameAndVersion);
+            } catch (e) {
+                p.put("error", e.toString());
+            }
+            break;
+        case ParamDef.LOADED_CLASS_REDEFINE:
+            self._dataPackSender.sendResponseHide(p.getResponse());
+            break;
+        case ParamDef.NODE_MODULE_DEPENDENCY:
+
+            var mv = new MapValue();
+            try {
+                var dependencies = PackageCtrHelper.getDependencies();
+                var keys = Object.keys(dependencies);
+
+                for (var i = 0; i < keys.length; i++) {
+                    mv.putString(keys[i], JSON.stringify(dependencies[keys[i]]));
+                }
+                p.putValue("module", mv);
+            } catch (e) {
+                Logger.printError('WHATAP-003', 'Node Module Dependency ', e, true);
+            }
+            self._dataPackSender.sendResponseHide(p.getResponse());
+            break;
+        case ParamDef.GET_ENV:
+            try {
+                var mv = new MapValue();
+                let ignore_env_variable = conf.getProperty('ignore_env_variable_set', '');
+                let ignore_env_variable_set = ignore_env_variable ? new Set(ignore_env_variable.split(',').map(item => item.trim())) : new Set();
+                for (var k in process.env) {
+                    if(ignore_env_variable_set.has(k)) {
+                        continue;
+                    }
+                    var v = process.env[k];
+                    mv.putString(k, v);
+                }
+                p.putValue("env", mv);
+            } catch (e) {
+                p.putValue("error", e.toString());
+            }
+            self._dataPackSender.sendResponseHide(p.getResponse());
+            break;
+
+        case ParamDef.SYSTEM_GC:
+            try {
+                var mem1 = process.memoryUsage();
+                var total1 = mem1.heapTotal;
+                var used1 = mem1.heapUsed;
+
+                if (global && global.gc && typeof global.gc === 'function') {
+                    global.gc();
+                } else {
+                    Logger.printError('WHATAP-177', 'Garbage collection unavailable.  Pass --expose-gc '
+                        + 'when launching node to enable forced garbage collection.', new Error());
+                }
+
+                var mem2 = process.memoryUsage();
+                var total2 = mem2.heapTotal;
+                var used2 = mem2.heapUsed;
+
+                var mv = new MapValue();
+                mv.putLong("before-t", total1);
+                mv.putLong("before-u", used1);
+                mv.putLong("after-t", total2);
+                mv.putLong("after-u", used2);
+                p.putValue("gc", mv);
+            } catch (e) {
+                p.putValue("error", e.toString());
+            }
+            self._dataPackSender.sendResponseHide(p.getResponse());
+            break;
+        case ParamDef.SET_CONFIG:
+            try {
+                var mv = p.getValue('config');
+                var en = mv.keys();
+                var props = {};
+                while(en.hasMoreElements()){
+                    var key = en.nextElement();
+                    var val = mv.getText(key);
+                    props[key] = val
+                }
+                Configure.saveProperty(props);
+            } catch (e) {
+                p.putValue("error", e.toString())
+            }
+            self._dataPackSender.sendResponseHide(p.getResponse());
+            break;
+
+        case ParamDef.LOADED_CLASS_DETAIL:
+
+            break;
+
+        case ParamDef.OPEN_SOCKET_LIST:
+
+            break;
+
+        case ParamDef.RESET_STRING_SENT_MARK:
+            break;
+        case ParamDef.AGENT_LOG_LIST:
+            var o = Logger.getLogFiles();
+            if (o !== null) {
+                p.putValue("files", o);
+            }
+            self._dataPackSender.sendResponseHide(p.getResponse());
+            break;
+
+        case ParamDef.AGENT_LOG_READ:
+            var file = p.getText("file");
+            var endpos = p.getNumber("pos");
+            var length = p.getNumber("length"); // 최대 16k 만 가능함...
+            length = Math.min(length, 8000);
+            if (endpos == 0) {
+                endpos += length;
+            }
+            Logger.read(file, endpos, length, function (before, next, text) {
+                p.putLong("before", before);
+                p.putLong("next", next);
+                p.putString("text", text);
+                self._dataPackSender.sendResponseHide(p.getResponse());
+            });
+            break;
+        case ParamDef.GET_TOPOLOGY:
+            try {
+                const node = await new StatusDetector().process();
+                if (node) {
+                    p.putValue("node", new BlobValue(node.toBytes()));
+                }
+                this._dataPackSender.sendResponseHide(p.getResponse());
+            } catch (e) {
+                Logger.printError('WHATAP-203', 'Node Module Dependency ', e, true);
+            }
+            break;
+    }
+}
+
+function getActiveTxList() {
+    var out = new MapValue()
+    var time = out.newList("time");
+    var tx_hash = out.newList("tx_hash");
+    var tx_name = out.newList("tx_name");
+    var profile = out.newList("profile");
+    var ip = out.newList("ip");
+
+    var userid = out.newList("userid");
+    var elapsed = out.newList("elapsed");
+    var cputime = out.newList("cputime");
+    var malloc = out.newList("malloc");
+    var sqlCount = out.newList("sqlCount");
+
+    var sqlTime = out.newList("sqlTime");
+    var httpcCount = out.newList("httpcCount");
+    var httpcTime = out.newList("httpcTime");
+    var threadId = out.newList("threadId");
+    var threadStat = out.newList("threadStat");
+
+    var act_dbc = out.newList("act_dbc");
+    var act_sql = out.newList("act_sql");
+    var act_httpc = out.newList("act_httpc");
+
+
+    var currentTime = DateUtil.currentTime();
+
+    //여기서 초기화가 안된 상태인경우가 있음..
+    TraceContextManager = require('../trace/trace-context-manager');
+    var en = TraceContextManager.getContextEnumeration();
+
+    while (en.hasMoreElements()) {
+        var ctx = en.nextElement();
+        if (ctx == null)
+            continue;
+
+        time.addLong(currentTime);
+        tx_hash.addLong(ctx.service_hash);
+        tx_name.addString(ctx.service_name);
+        profile.addLong(ctx.txid);
+        ip.addLong(ctx.remoteIp);
+        userid.addLong(ctx.userid);
+        elapsed.addLong(ctx.getElapsedTime());
+        cputime.addLong(ResourceProfile.getCPUTime() - ctx.start_cpu);
+        var m = ResourceProfile.getUsedHeapSize() - ctx.start_malloc;
+        malloc.addLong(m < 0 ? 0 : m);
+        sqlCount.addLong(ctx.sql_count);
+        sqlTime.addLong(ctx.sql_time);
+        httpcCount.addLong(ctx.httpc_count);
+        httpcTime.addLong(ctx.httpc_time);
+        threadId.addLong(ctx._id);
+        threadStat.addLong(0);
+
+        act_dbc.addLong(ctx.active_dbc);
+        act_sql.addLong(ctx.active_sqlhash);
+
+        act_httpc.addLong(ctx.active_httpc_hash);
+    }
+    return out;
+}
+
+function getCurrentStackDetail(traceId, txid) {
+    var out = new MapValue();
+
+    var ctx = TraceContextManager.getContext(traceId);
+    if (ctx != null && ctx.txid.equals(txid)) {
+        out.putLong("time", DateUtil.currentTime());
+        out.putLong("tx_hash", ctx.service_hash);
+        out.putString("tx_name", ctx.service_name);
+        out.putLong("profile", ctx.txid);
+        out.putLong("ip", ctx.remoteIp);
+        out.putLong("userid", ctx.userToken);
+        out.putLong("elapsed", ctx.getElapsedTime());
+        out.putLong("sqlCount", ctx.sql_count);
+        out.putLong("sqlTime", ctx.sql_time);
+        out.putLong("httpcCount", ctx.httpc_count);
+        out.putLong("httpcTime", ctx.httpc_time);
+        out.putLong("threadId", ctx.thread_id);
+
+        ///////////////////
+        if (ctx.http_content_type != null) {
+            out.putString("httpContentType", ctx.http_content_type);
+        }
+        ///////////////////
+
+        if (ctx.active_sqlhash != 0) {
+            out.putLong("act_dbc", ctx.active_dbc);
+            out.putLong("act_sql", ctx.active_sqlhash);
+        }
+        if (ctx.active_httpc_hash != 0) {
+            out.putLong("act_httpc", ctx.active_httpc_hash);
+            out.putLong("act_httpc_host", ctx.httpc_host);
+            out.putLong("act_httpc_port", ctx.httpc_port);
+        }
+        out.putString("method", ctx.http_method);
+
+        if (ctx.mtid.isZero() === false) {
+            out.putLong("mtid", ctx.mtid);
+            out.putLong("mdepth", ctx.mdepth);
+            out.putLong("mcaller", ctx.mcaller_txid);
+        }
+
+        // var se = ctx.stack;
+        // var stack = out.newList("callstack");
+        // for (var i = 0; i < se.length; i++) {
+        //     stack.addString(se[i]);
+        // }
+
+        var stack = out.newList("callstack");
+        stack.addString("Last step time: " + new Date(ctx.last_footprint_time).toString());
+        stack.addString("Last step to now: " +(Date.now() - ctx.last_footprint_time) +" ms");
+        stack.addString("Last step message: " + ctx.last_footprint_desc);
+
+
+    }
+    return out;
+}
+module.exports = new ControlHandler();

package/lib/control/packagectr-helper.js

@@ -8,6 +8,8 @@ var fs      = require('fs'),
     path    = require('path');
 
 var TraceContextManager = require('../trace/trace-context-manager'),
+    DataTextAgent       = require('../data/datatext-agent'),
+    MethodStep          = require('../step/method-stepx'),
     HashUtil            = require('../util/hashutil'),
     ArrayUtil           = require('../util/array-util'),
     conf                = require('../conf/configure'),
@@ -24,9 +26,38 @@ PackageCtrHelper.addPackage = function(realPath){
             loadedPackages[realPath] = require(realPath);
         }
     } catch(e) {
-        return Logger.printError("WHATAP-120", "PackageControler helper", e, false);
+        return Logger.printError("WHATAP-512", "PackageControler helper", e, false);
     }
 };
+PackageCtrHelper.dynamicHook = function(pkg, realPath, funcName) {
+    if(!pkg || !funcName) {
+        return;
+    }
+
+    var Interceptor = require('../core/interceptor').Interceptor;
+    var _aop = new Interceptor(null);
+    _aop.both(pkg, funcName,
+        function(obj, args, lctx){
+            // transaction step
+            var ctx = lctx.context;
+            if(!ctx) { return; }
+
+            var msg = realPath + ' ' + funcName;
+            var hash = HashUtil.hashFromString(msg);
+            var step = new MethodStep();
+            DataTextAgent.METHOD.add(hash, msg);
+            step.hash = hash;
+            step.start_time = ctx.getElapsedTime();
+            pkg.__whatap_step__ = step;
+        },
+        function(obj, args, ret, lctx){
+            var ctx = lctx.context;
+            if(!ctx) { return; }
+            var step = pkg.__whatap_step__;
+            step.elapsed = ctx.getElapsedTime() - step.start_time;
+            ctx.profile.add(step);
+        });
+};
 PackageCtrHelper.getLoadedPackageList = function(filter){
     return loadedPackageList;
 };
@@ -51,7 +82,7 @@ PackageCtrHelper.getInstalledPackageList = function(){
         }
         return dirs;
     } catch(e) {
-        Logger.printError('WHATAP-121', 'Get Installed Package List ', e, true);
+        Logger.printError('WHATAP-004', 'Get Installed Package List ', e, true);
     }
 
     return [];
@@ -65,7 +96,7 @@ PackageCtrHelper.getPackageDetail = function(pkg){
             packageJson = JSON.parse(packageFile);
         return packageJson.dependencies;
     } catch(e) {
-        Logger.printError('WHATAP-122', 'Get Package Detail ', e, true);
+        Logger.printError('WHATAP-005', 'Get Package Detail ', e, true);
     }
 };