whatap 1.0.1 → 1.0.2

package/lib/core/interceptor.js

@@ -35,7 +35,7 @@ Interceptor.prototype.before = function(obj, funcs, advice, isCallback) {
                 try {
                     advice(this, arguments);
                 } catch (e) {
-                    Logger.printError("WHATAP-114", "Interceptor error", e);
+                    Logger.printError("WHATAP-500", "Interceptor error", e);
                 }
                 return orig.apply(this, arguments);
             }
@@ -60,7 +60,7 @@ Interceptor.prototype.after = function(obj, funcs, advice) {
             try {
                 funcRet = advice(this, arguments, ret);
             } catch(e) {
-                Logger.printError('WHATAP-115', 'Interceptor after error', e);
+                Logger.printError('WHATAP-177', 'Interceptor after error', e);
             }
 
             return funcRet || ret;
@@ -90,7 +90,7 @@ Interceptor.prototype.both = function(obj, funcs, beforeFunc, afterFunc) {
             try {
                 beforeFunc(this, arguments, local_ctx);
             } catch(e) {
-                Logger.printError('WHATAP-116', 'Interceptor both before error', e);
+                Logger.printError('WHATAP-178', 'Interceptor both before error', e);
             }
 
             var ret = orig.apply(this, arguments);
@@ -100,7 +100,7 @@ Interceptor.prototype.both = function(obj, funcs, beforeFunc, afterFunc) {
                     funcRet = afterFunc(this, arguments, ret, local_ctx);
                 }
             } catch(e) {
-                Logger.printError("WHATAP-117", "Interceptor both after error", e);
+                Logger.printError("WHATAP-501", "Interceptor both after error", e);
             }
 
             return funcRet || ret;
@@ -122,7 +122,7 @@ Interceptor.prototype.functionHook = function(args, pos, beforeFunc, afterFunc)
             try {
                 beforeFunc(this, arguments);
             } catch(e) {
-                Logger.printError("WHATAP-118", 'Interceptor functionhook before error', e);
+                Logger.printError("WHATAP-179", 'Interceptor functionhook before error', e);
             }
         }
 
@@ -132,7 +132,7 @@ Interceptor.prototype.functionHook = function(args, pos, beforeFunc, afterFunc)
             try {
                 afterFunc(this, arguments, result);
             } catch(e) {
-                Logger.printError("WHATAP-119", 'Interceptor functionhook after error', e);
+                Logger.printError("WHATAP-180", 'Interceptor functionhook after error', e);
             }
         }
         return result;

package/lib/core/request-agent.js

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+
+
+const http = require('http');
+var keepAliveAgent = new http.Agent({ keepAlive: true });
+
+
+var baseConfig = {
+  keepAlive: true,
+  keepAliveTimeoutMsecs: 500,
+  maxSockets: 1 // requests are serialized
+}
+
+baseConfig.agent = keepAliveAgent;
+
+
+http.request(baseConfig, onResponseCallback);
+
+
+
+var RequestAgent = function(){
+
+}

package/lib/core/shimmer.js

@@ -1,10 +1,10 @@
 'use strict'
 
-function isFunction (funktion) {
+function isFunction(funktion) {
     return typeof funktion === 'function'
 }
 
-function defineProperty (obj, name, value) {
+function defineProperty(obj, name, value) {
     var enumerable = !!obj[name] && obj.propertyIsEnumerable(name)
     Object.defineProperty(obj, name, {
         configurable: true,
@@ -14,10 +14,28 @@ function defineProperty (obj, name, value) {
     })
 }
 
-var shimmer = function () {
-}
+var shimmer = function() {}
+
+/**
+ * Wrap a single method or multiple methods with the provided wrapper function
+ *
+ * @param {Object} nodule - The object containing methods to wrap
+ * @param {string|Array<string>} name - Method name or array of method names to wrap
+ * @param {Function} wrapper - The wrapper function
+ * @returns {Function|Array<Function>} - The wrapped function(s)
+ */
+var wrap = function(nodule, name, wrapper) {
+    // If name is an array, recursively call wrap for each name in the array
+    if (Array.isArray(name)) {
+        var wrapped = [];
+        name.forEach(function(methodName) {
+            var result = wrap(nodule, methodName, wrapper);
+            if (result) wrapped.push(result);
+        });
+        return wrapped.length > 0 ? wrapped : undefined;
+    }
 
-var wrap = function (nodule, name, wrapper) {
+    // Standard single method wrap logic
     if (!nodule || !nodule[name]) {
         return;
     }
@@ -27,67 +45,95 @@ var wrap = function (nodule, name, wrapper) {
     }
 
     if (!isFunction(nodule[name]) || !isFunction(wrapper)) {
-        return
+        return;
     }
 
-    var original = nodule[name]
-    var wrapped = wrapper(original, name)
+    var original = nodule[name];
+    var wrapped = wrapper(original, name);
 
-    defineProperty(wrapped, '__original', original)
-    defineProperty(wrapped, '__unwrap', function () {
-        if (nodule[name] === wrapped) defineProperty(nodule, name, original)
-    })
-    defineProperty(wrapped, '__wrapped', true)
+    defineProperty(wrapped, '__original', original);
+    defineProperty(wrapped, '__unwrap', function() {
+        if (nodule[name] === wrapped) defineProperty(nodule, name, original);
+    });
+    defineProperty(wrapped, '__wrapped', true);
 
-    defineProperty(nodule, name, wrapped)
-    return wrapped
+    defineProperty(nodule, name, wrapped);
+    return wrapped;
 }
 
-function unwrap (nodule, name) {
+/**
+ * Unwrap a single method or multiple methods
+ *
+ * @param {Object} nodule - The object containing wrapped methods
+ * @param {string|Array<string>} name - Method name or array of method names to unwrap
+ */
+function unwrap(nodule, name) {
+    // If name is an array, recursively call unwrap for each name in the array
+    if (Array.isArray(name)) {
+        name.forEach(function(methodName) {
+            unwrap(nodule, methodName);
+        });
+        return;
+    }
+
     if (!nodule || !nodule[name]) {
-        return
+        return;
     }
 
     if (!nodule[name].__unwrap) {
+        // Method is not wrapped
     } else {
-        return nodule[name].__unwrap()
+        return nodule[name].__unwrap();
     }
 }
 
-function massWrap (nodules, names, wrapper) {
+/**
+ * Wrap multiple methods of multiple modules with the same wrapper
+ *
+ * @param {Object|Array<Object>} nodules - Module or array of modules with methods to wrap
+ * @param {Array<string>} names - Array of method names to wrap
+ * @param {Function} wrapper - The wrapper function to apply
+ */
+function massWrap(nodules, names, wrapper) {
     if (!nodules) {
-        return
+        return;
     } else if (!Array.isArray(nodules)) {
-        nodules = [nodules]
+        nodules = [nodules];
     }
 
     if (!(names && Array.isArray(names))) {
-        return
+        return;
     }
 
-    nodules.forEach(function (nodule) {
-        names.forEach(function (name) {
-            wrap(nodule, name, wrapper)
-        })
-    })
+    nodules.forEach(function(nodule) {
+        names.forEach(function(name) {
+            wrap(nodule, name, wrapper);
+        });
+    });
 }
 
-function massUnwrap (nodules, names) {
+/**
+ * Unwrap multiple methods of multiple modules
+ *
+ * @param {Object|Array<Object>} nodules - Module or array of modules with wrapped methods
+ * @param {Array<string>} names - Array of method names to unwrap
+ */
+function massUnwrap(nodules, names) {
     if (!nodules) {
-        return
+        return;
     } else if (!Array.isArray(nodules)) {
-        nodules = [nodules]
+        nodules = [nodules];
     }
 
     if (!(names && Array.isArray(names))) {
-        return
+        return;
     }
 
-    nodules.forEach(function (nodule) {
-        names.forEach(function (name) {
-            unwrap(nodule, name)
-        })
-    })
+    nodules.forEach(function(nodule) {
+        names.forEach(function(name) {
+            unwrap(nodule, name);
+        });
+    });
 }
 
 shimmer.wrap = wrap;

package/lib/counter/counter-manager.js

@@ -4,32 +4,70 @@
  * can be found in the LICENSE file.
  */
 
-var TraceContextManager = require('../trace/trace-context-manager'),
+var CounterPack = require('../pack/counter-pack'),
+    Service = require('./task/service'),
+    AgentInfo = require('./task/agentinfo'),
+    ActiveTransaction = require('./task/activetransaction'),
+    ProcCpu = require('./task/proc-cpu'),
+    ResSysCpu = require('./task/res-sys-cpu'),
+    HeapMem = require('./task/heapmem'),
+    SystemPerf = require('./task/systemperf'),
+    RealtimeUser = require('./task/realtimeuser'),
+    Socketio = require('./task/socketio'),
+    GCStat = require('./task/gcstat'),
+    Sql = require('./task/sql'),
+    HttpC = require('./task/httpc'),
+    MeteringInfo = require('./task/metering-info'),
+    GCAction = require('./task/gc-action'),
+    StatError = require('../stat/stat-error'),
+    TagCounterPack = require('../pack/tagcount-pack'),
+    TraceContextManager = require('../trace/trace-context-manager'),
     secuMaster = require('../net/security-master'),
+    DataPackSender = require('../data/datapack-sender'),
     conf = require('../conf/configure'),
     DateUtil = require('./../util/dateutil'),
-    Logger              = require('../logger'),
-    GCAction = require('../system/gc-action');
+    KubeClient       = require('../kube/kube-client'),
+    KubeUtil            = require('../util/kube-util'),
+    Logger              = require('../logger');
 
 function CounterManager(agent) {
     this.agent = agent;
     this.time = Date.now();
-    
+
     this.intervalIndex = undefined;
 };
 CounterManager.plugin={}
 CounterManager.prototype.run = function () {
-    let self = this;
+    var self = this;
+
     process.nextTick(function () {
         var tasks = [];
+        tasks.push(new Service());
+        tasks.push(new AgentInfo());
+        tasks.push(new ActiveTransaction());
+        tasks.push(new RealtimeUser());
+        tasks.push(new HeapMem());
+        tasks.push(new ProcCpu());
+        tasks.push(new ResSysCpu());
+        tasks.push(new SystemPerf());
+        tasks.push(new Socketio());
+        tasks.push(new GCStat());
+        tasks.push(new Sql());
+        tasks.push(new HttpC());
         tasks.push(new GCAction());
 
+        // metering
+        tasks.push(new MeteringInfo());
         self.intervalIndex = setInterval(function(){
             self.process(tasks);
         },5000);
-
         self.process(tasks);
     });
+
+    if(conf.whatap_micro_enabled || process.env.WHATAP_MICRO_ENABLED === "true"){
+        KubeUtil.loadContainerId();
+        if (conf.enabled_master_agent_call) KubeClient.run();
+    }
 };
 CounterManager.prototype.stop = function(){
     if(this.intervalIndex){
@@ -52,16 +90,49 @@ CounterManager.prototype.process = function (tasks) {
         return;
     }
 
+    var enumer = TraceContextManager.getContextEnumeration();
+    while (enumer.hasMoreElements()) {
+        var ctx = enumer.nextElement();
+        if (ctx.getElapsedTime() > conf.profile_max_time) {
+            //TraceContextManager.end(ctx._id);
+            if(conf.getProperty("ignore_http_lost_connection", false) === true){
+                Logger.print("WHATAP-072", "Lost Connection was ignored, " + ctx._id, false);
+                TraceContextManager.end(ctx._id);
+                ctx = null;
+            }else{
+                // var obj = TraceContextManager.resume(ctx._id);
+                TraceContextManager.addStep("Lost Connection","", ctx);
+                //ctx.status = 5;
+                //ctx.error = StatError.addError(500, "Lost Connection", ctx.service_hash);
+                TraceContextManager.endTrace(ctx);
+            }
+        }
+    }
+
     if (conf.counter_enabled) {
+        var pack = new CounterPack();
+        pack.pcode = secuMaster.PCODE;
+        pack.oid = secuMaster.OID;
+        pack.time = Math.floor(DateUtil.currentTime() / 5000) * 5000;
+        pack.duration = Math.floor(interval / 1000);
         for (var i = 0; i < len; i++) {
             task = tasks[i];
             try{
-                task.process();
+                task.process(pack);
             } catch (e) {
-                Logger.printError('WHATAP-603', 'Counter Manager process ', e, true);
+                Logger.printError('WHATAP-070', 'Counter Manager process ', e, true);
             }
         }
+        pack.starttime = this.agent.starttime;
 
+        try {
+            if (CounterManager.plugin["extra"]) {
+                CounterManager.plugin["extra"](pack);
+            }
+        } catch (e) {
+            Logger.printError('WHATAP-071', 'Counter Manager Plugin ', e, true);
+        }
+        DataPackSender.sendCounterPack(pack);
     }
 };
 

package/lib/counter/meter/meter-activex.js

@@ -0,0 +1,67 @@
+/**
+ * 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'),
+    IntIntMap = require('../../util/intint-map'),
+    secuMaster = require('../../net/security-master'),
+    LinkedMap = require('../../util/linkedmap');
+
+
+function MeterActiveX() {
+    this.statByOid = new IntIntMap().setMax(2001);
+    this.statByGroup = createLinkedMap();
+    this.stat_sql = new IntIntMap().setMax(301);
+    this.stat_httpc = new IntIntMap().setMax(301);
+    this.unknown = 0;
+}
+
+MeterActiveX.prototype.addTx = function (caller_pcode, caller_okind, caller_oid) {
+    if (caller_oid) {
+        this.statByGroup.add({pcode:caller_pcode, okind:caller_okind}, 1);
+        if (caller_pcode == secuMaster.PCODE) {
+            this.statByOid.add(caller_oid, 1);
+        }
+    } else {
+        this.unknown++;
+    }
+
+};
+MeterActiveX.prototype.addSql = function (dbc) {
+    this.stat_sql.add(dbc, 1);
+};
+
+MeterActiveX.prototype.addHttpc = function (host) {
+    this.stat_httpc.add(host, 1);
+};
+
+MeterActiveX.prototype.reinit = function () {
+    this.statByOid = new IntIntMap().setMax(2001);
+    this.statByGroup = createLinkedMap();
+    this.stat_sql = new IntIntMap().setMax(301);
+    this.stat_httpc = new IntIntMap().setMax(301);
+    this.unknown = 0;
+};
+
+
+function createLinkedMap() {
+    var m = new LinkedMap(1009, 1).setMax(307);
+    m.hash = function (k) {
+        if (k._hash_) {
+            return k._hash_;
+        }
+        var result = 1;
+        result = 31 * result + k.pcode;
+        result = 31 * result + k.okind;
+
+        k._hash_ = result;
+        return result;
+    };
+    m.equals = function (k1, k2) {
+        return k1.pcode === k2.pcode && k1.okind === k2.okind;
+    };
+    return m;
+}
+module.exports = new MeterActiveX();

package/lib/counter/meter/meter-httpc.js

@@ -0,0 +1,57 @@
+/**
+ * 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 IntKeyLinkedMap = require('../../util/intkey-linkedmap');
+var Long            = require('long');
+var Logger      = require('../../logger');
+var conf      = require('../../conf/configure');
+    
+function Bucket() {
+    this.count = 0;
+    this.time =0;
+    this.error = 0;
+}
+
+function MeterHttpC() {
+    this.bucket = new Bucket();
+    this.stat = new IntKeyLinkedMap(309, 1).setMax(307);
+    this.stat.create = function (key) {
+			return new Bucket();
+	};
+}
+
+MeterHttpC.prototype.add = function (host,elapsed, err) {
+    try {
+        var b = this.bucket;
+        b.count++;
+        b.time += elapsed;
+        if(err) {
+            b.error++;
+        }
+
+        if (conf.httpc_host_meter_enabled && host != 0) {
+			b = this.stat.intern(host);
+			b.count++;
+			b.time += elapsed;
+			if (err) {
+				b.error++;
+            }
+		}
+    } catch(e) {
+        Logger.printError("WHATAP-608", "MeterHttpC Error", e);
+    }
+};
+MeterHttpC.prototype.getBucketReset = function () {
+    var b = this.bucket;
+    this.bucket = new Bucket();
+    return b;
+};
+MeterHttpC.prototype.resetStat = function () {
+    if(this.stat.size() > 0){
+        this.stat.clear();
+    }
+}
+module.exports = new MeterHttpC();

package/lib/counter/meter/meter-resource.js

@@ -0,0 +1,9 @@
+/**
+ * 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 MeterResource() {
+    
+};

package/lib/counter/meter/meter-service.js

@@ -0,0 +1,168 @@
+/**
+ * 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 HitMapPack1 = require('../../pack/hitmap-pack1'),
+    IntKeyMap = require('../../util/intkey-map'),
+    SecurityMaster   = require('../../net/security-master'),
+    conf = require('../../conf/configure'),
+    secu = require('../../net/security-master'),
+    IntKeyLinkedMap    = require('../../util/intkey-linkedmap'),
+    LinkedMap    = require('../../util/linkedmap'),
+    Logger       = require('../../logger'),
+    EventLevel  = require('../../data/event-level');
+    Long = require('long');
+
+function Bucket () {
+    this.hitmap = new HitMapPack1();
+    this.count = 0;
+    this.timesum = 0;
+    this.error = 0;
+    this.count_satisfied = 0;
+    this.count_tolerated = 0;
+
+    this.reset = function () {
+        this.count = 0;
+        this.timesum = 0;
+        this.error = 0;
+        this.count_satisfied = 0;
+        this.count_tolerated = 0;
+        this.hitmap = new HitMapPack1();
+    };
+}
+function BucketSimple () {
+    this.count = 0;
+    this.timesum = 0;
+    this.error = 0;
+    this.count_satisfied = 0;
+    this.count_tolerated = 0;
+
+    this.reset = function () {
+        this.count = 0;
+        this.timesum =0;
+        this.error = 0;
+        this.count_satisfied = 0;
+        this.count_tolerated = 0;
+    };
+}
+
+function MeterService() {
+    if(typeof MeterService.instance === 'object') {
+        return MeterService.instance;
+    }
+    this.bucket = new Bucket();
+    this.unknown = new BucketSimple();
+    this.stat = new IntKeyLinkedMap(309, 1).setMax(307);
+    this.stat.create = function (key) {
+        return new BucketSimple();
+	};
+	this.statByGroup = new LinkedMap(309, 1).setMax(307);
+    this.statByGroup.create = function (key) {
+        return new BucketSimple();
+    };
+    this.statByGroup.hash = function (k) {
+        if(k._hash_){
+            return k._hash_;
+        }
+        var result = 1;
+        result = 31 * result + k.pcode;
+        result = 31 * result + k.okind;
+        
+        k._hash_=result;
+        return result;
+    };
+    this.statByGroup.equals = function (k1,k2) {
+        return k1.pcode === k2.pcode && k1.okind === k2.okind;
+    };
+
+    MeterService.instance = this;
+}
+
+MeterService.prototype.add = function (serviceHash, elapsed, errorLevel, caller_pcode,  caller_okind,  caller_oid , apdex) {
+    if(elapsed < 0) {
+        elapsed = 0;
+    }
+
+    var b = this.bucket;
+    b.count += 1;
+    b.timesum +=elapsed;
+    
+    var err = errorLevel >= EventLevel.WARNING;
+    if (err) {
+        b.error += 1;
+    } else {
+        if (elapsed <= conf.apdex_time_t) {
+            b.count_satisfied += 1;
+            apdex=2;
+        } else if (elapsed <= conf.apdex_time_4t) {
+            b.count_tolerated += 1;
+            apdex=1;
+        }
+    }
+    b.hitmap.add(elapsed, err);
+    
+    if (conf.tx_caller_meter_enabled) {
+        try{
+            var b1 = null;
+            if(  caller_oid) {
+                if (caller_pcode == SecurityMaster.PCODE) {
+                        b1 = this.stat.intern(caller_oid);
+                        b1.count++;
+                        b1.timesum += elapsed;
+                        if (err) {
+                            b1.error++;
+                        }
+                }
+                
+                b1 = this.statByGroup.intern({pcode:caller_pcode, okind:caller_okind});
+                b1.count++;
+                b1.timesum += elapsed;
+                if (err) {
+                    b1.error++;
+                }
+            }else {
+                b1 = this.unknown;
+                b1.count++;
+                b1.timesum += elapsed;
+                if (err) {
+                    b1.error++;
+                }
+            }
+        }catch(e){
+            Logger.printError('WHATAP-080', 'Meter Service add ', e, true);
+        }
+    }
+};
+MeterService.prototype.getBucket = function () {
+    return this.bucket;
+};
+MeterService.prototype.resetStat = function () {
+    if(this.stat.size() > 0){
+        this.stat.clear();
+    }
+    if(this.statByGroup.size() > 0){
+        this.statByGroup.clear();
+    }
+    if (this.unknown.count > 0) {
+        this.unknown = new Bucket();
+    }
+};
+
+function TopService(hash) {
+    this.hash = hash | 0;
+    this.count = 0;
+    this.error = 0;
+    this.time = 0;
+
+    this.clear = function () {
+        this.count = 0;
+        this.error = 0;
+        this.time = 0;
+    };
+};
+
+module.exports.MeterService = new MeterService();
+module.exports.Bucket = Bucket;
+module.exports.TopService = TopService;