whatap 1.0.1 → 1.0.2

package/lib/{system → counter/task}/gc-action.js

@@ -4,22 +4,18 @@
  * can be found in the LICENSE file.
  */
 
-var CounterTask     = require('../../lib/counter/task/counter-task'),
-    conf = require('../../lib/conf/configure'),
-    DateUtil = require('../../lib/util/dateutil'),
-    Logger = require('../../lib/logger'),
-    TagCountPack = require('../../lib/pack/tagcount-pack'),
-    HashUtil = require('../../lib/util/hashutil'),
-    SecurityMaster = require('../../lib/net/security-master'),
-    NodeUtil = require('../../lib/util/nodeutil'),
-    IPUtil = require('../../lib/util/iputil'),
-    AsyncSender = require('../../lib/udp/async_sender'),
-    DataOutputX = require('../../lib/io/data-outputx'),
-    ParamPack = require('../pack/param-pack').ParamPack,
-    MapValue = require('../value/map-value');
+var CounterTask     = require('./counter-task'),
+    DataPackSender  = require('../../data/datapack-sender'),
+    conf = require('../../conf/configure'),
+    DateUtil = require('../../util/dateutil'),
+    Logger = require('../../logger'),
+    TagCountPack = require('../../pack/tagcount-pack'),
+    HashUtil = require('../../util/hashutil'),
+    SecurityMaster = require('../../../lib/net/security-master'),
+    NodeUtil = require('../../util/nodeutil'),
+    IPUtil = require('../../util/iputil');
 
 const { PerformanceObserver } = require('perf_hooks');
-const DataOuputX = require('../../lib/io/data-outputx');
 
 function GCAction() {
     CounterTask.call(this);
@@ -40,19 +36,19 @@ GCAction.prototype.checkGCObserverSupport = function () {
     }
 };
 
-GCAction.prototype.process = function () {
+GCAction.prototype.process = function (p) {
     try {
         if (!conf.getProperty('perfx_nodejs_gc_enabled', false) || !this.isObserverSupported) {
             return;
         }
 
-        this.getNodeMemoryGC();
+        this.nodejs_memory_gc(p);
     } catch (e) {
         Logger.printError("WHATAP-GC-003", "NodeJS GC process error", e, false);
     }
 };
 
-GCAction.prototype.getNodeMemoryGC = function () {
+GCAction.prototype.nodejs_memory_gc = function (p) {
     const gcStats = new Map();
     const self = this;
 
@@ -82,7 +78,7 @@ GCAction.prototype.getNodeMemoryGC = function () {
 
             // 수집된 데이터가 있으면 전송
             if (gcStats.size > 0) {
-                self.sendGCData(gcStats);
+                self.sendGCData(p, gcStats);
             }
         });
 
@@ -92,21 +88,20 @@ GCAction.prototype.getNodeMemoryGC = function () {
     }
 };
 
-GCAction.prototype.sendGCData = function (gc_stats) {
-    var p = new TagCountPack();
-    p.pcode = SecurityMaster.PCODE;
-    p.time = Math.floor(Date.now() / 1000) * 1000;
-    p.category = "nodejsx_memory_gc";
+GCAction.prototype.sendGCData = function (p, gc_stats) {
+    const pk = new TagCountPack();
+    pk.time = Math.floor(Date.now() / 1000) * 1000;
+    pk.category = "nodejsx_memory_gc";
 
-    p.putTagString("oname", SecurityMaster.ONAME);
-    p.putTagString("host_ip", IPUtil.getIp());
-    p.putTagInt("pid", process.pid);
-    p.putTagInt("!rectype", 2);
+    pk.putTagString("oname", SecurityMaster.ONAME);
+    pk.putTagString("host_ip", IPUtil.getIp());
+    pk.putTagInt("pid", process.pid);
+    pk.putTagInt("!rectype", 2);
 
-    const idLv = p.fields.internList("@id");
-    const nameLv = p.fields.internList("name");
-    const countLv = p.fields.internList("CollectionCount");
-    const timeLv = p.fields.internList("CollectionTime");
+    const idLv = pk.fields.internList("@id");
+    const nameLv = pk.fields.internList("name");
+    const countLv = pk.fields.internList("CollectionCount");
+    const timeLv = pk.fields.internList("CollectionTime");
 
     // GC 통계 데이터 추가
     for (const [gc_name, stats] of gc_stats) {
@@ -116,51 +111,9 @@ GCAction.prototype.sendGCData = function (gc_stats) {
         timeLv.addLong(Math.round(stats.collectionTime));
     }
 
-    const bout = new DataOuputX();
-    bout.writePack(p, null);
-    const packbytes = bout.toByteArray();
-
-    AsyncSender.send_relaypack(packbytes)
+    DataPackSender.sendTagCounterPack(pk);
 };
 
-GCAction.prototype.execSystemGC = function () {
-    var p = new ParamPack();
-    p.pcode = SecurityMaster.PCODE;
-    p.oid = SecurityMaster.OID;
-    p.oname = SecurityMaster.ONAME;
-    p.okind = SecurityMaster.OKIND;
-    // p.oid
-    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-601', '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);
-
-        return p;
-    } catch (e) {
-        // p.putValue("error", e.toString());
-        console.log(`e: ${e}`)
-    }
-    return null;
-}
-
 GCAction.prototype.getGCTypeName = function (kind) {
     const major = NodeUtil.getNodeMajorVersion();
 

package/lib/counter/task/gcstat.js

@@ -0,0 +1,34 @@
+/**
+ * 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');
+
+function GcStat() {
+    CounterTask.call(this);
+
+    this.old = [];
+}
+
+GcStat.prototype = new CounterTask();
+GcStat.prototype.constructor = GcStat;
+GcStat.prototype.process = function (p) {
+    var info = ResourceProfile.getCurrentProcGcInfo();
+    if(this.old.length == 0) {
+        p.gc_count = info[0];
+        p.gc_time = info[1];
+    } else {
+        var tmp_count = info[0] - this.old[0];
+        var tmp_time = info[1] - this.old[1];
+        p.gc_count = tmp_count;
+        p.gc_time = tmp_time;
+        
+    }
+    this.old = info;
+};
+
+module.exports = GcStat;
+

package/lib/counter/task/heapmem.js

@@ -0,0 +1,25 @@
+/**
+ * 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');
+
+function HeapMem() {
+    CounterTask.call(this);
+}
+
+HeapMem.prototype = new CounterTask();
+HeapMem.prototype.constructor = HeapMem;
+HeapMem.prototype.process = function (p) {
+    let m = undefined;
+    if(p.version <= 1) m =ResourceProfile.getMemory();
+    else m =ResourceProfile.getMemoryV2();
+
+    p.heap_tot = m.heap_total;
+    p.heap_use = m.heap_used;
+};
+
+module.exports = HeapMem;

package/lib/counter/task/httpc.js

@@ -0,0 +1,76 @@
+/**
+ * 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'),
+    IntKeyLinkedMap = require('../../util/intkey-linkedmap'),
+    MeterActiveX = require('../meter/meter-activex'),
+    conf = require('../../conf/configure'),
+    MeterHttpC = require('../meter/meter-httpc');
+
+function HttpC() {
+    CounterTask.call(this);
+}
+
+HttpC.prototype = new CounterTask();
+HttpC.prototype.constructor = HttpC;
+HttpC.prototype.process = function (p) {
+    var httpc = MeterHttpC.getBucketReset();
+    p.httpc_time = httpc.time;
+    p.httpc_count = httpc.count;
+    p.httpc_error = httpc.error;
+
+    if (conf.httpc_host_meter_enabled) {
+        httpc_host_meter(p);
+    }
+    if (conf.actx_meter_enabled) {
+        httpc_actx_meter(p);
+    }
+};
+
+function httpc_host_meter(p) {
+    var meter = MeterHttpC;
+    if (meter.stat.size() > 0) {
+        p.httpc_meter = new IntKeyLinkedMap();
+        var en = meter.stat.keys();
+        for (var i = 0; i < 100 && en.hasMoreElements(); i++) {
+            var key = en.nextElement();
+            var b = meter.stat.get(key);
+            p.httpc_meter.put(key, {
+                time: b.time,
+                count: b.count,
+                error: b.error,
+                actx : 0
+            });
+        }
+        meter.resetStat();
+    }
+}
+
+function httpc_actx_meter(p) {
+    var meter = MeterActiveX;
+    if (meter.stat_httpc.size() > 0) {
+        if (p.httpc_meter == null) {
+            p.httpc_meter = new IntKeyLinkedMap();
+        }
+        var en = meter.stat_httpc.keys();
+        for (var i = 0; i < 100 && en.hasMoreElements(); i++) {
+            var key = en.nextElement();
+            var b = meter.stat_httpc.get(key);
+            var org = p.httpc_meter.get(key);
+            if (org) {
+                org.actx = b;
+            } else {
+                p.httpc_meter.put(key, {
+                    time: 0,
+                    count: 0,
+                    error: 0,
+                    actx: b
+                });
+            }
+        }
+    }
+}
+module.exports = HttpC;

package/lib/counter/task/metering-info.js

@@ -0,0 +1,125 @@
+/**
+ * Copyright 2025 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'),
+    DataPackSender  = require('../../data/datapack-sender'),
+    conf = require('../../conf/configure'),
+    DateUtil = require('../../util/dateutil'),
+    Logger = require('../../logger'),
+    fs = require('fs'),
+    TagCountPack = require('../../pack/tagcount-pack'),
+    OType = require('../../pack/otype'),
+    APEnum = require('../../pack/apenum'),
+    Util = require('../../util/index');
+
+function MeteringInfo() {
+    CounterTask.call(this);
+    this.first_connected = true;
+    this.lastTime = DateUtil.getFiveMinUnit(DateUtil.currentTime());
+    this.hostUUID = null;
+    this.csp = null;
+    this.hostUUIDFileName = '/sys/class/dmi/id/product_uuid';
+}
+
+MeteringInfo.prototype = new CounterTask();
+MeteringInfo.prototype.constructor = MeteringInfo;
+
+MeteringInfo.prototype.process = function (p) {
+    if (!conf.getProperty('metering_tagcount_enabled', false)) {
+        return;
+    }
+
+    if (this.first_connected) {
+        this.first_connected = false;
+        this.doProcess(p);
+        return;
+    }
+
+    const now = DateUtil.getFiveMinUnit(DateUtil.currentTime());
+    if (this.lastTime >= now) {
+        return;
+    }
+
+    this.lastTime = now;
+    this.doProcess(p);
+};
+
+MeteringInfo.prototype.doProcess = function (p) {
+    const host_uuid = this.getHostUUID(this.hostUUIDFileName);
+    if(!host_uuid)
+        return;
+
+    const pk = new TagCountPack();
+    pk.category = 'metering';
+    pk.time = DateUtil.currentTime() / 300000 * 300000;
+
+    pk.putTagInt('otype', OType.AP);
+    pk.putTagInt('subtype', APEnum.AP_NODE);
+    pk.putTagInt('ip', p.host_ip);
+    pk.putTagString('host_uuid', host_uuid);
+    pk.putTagString('_no_5m_hour_', "");
+
+    const csp = this.getCsp();
+    if (csp) {
+        pk.putTagString('csp', csp)
+    }
+
+    pk.putTagFloat('mcore', p.metering)
+
+    DataPackSender.sendTagCounterPack(pk);
+};
+
+MeteringInfo.prototype.hasHostUUID = function (fileName) {
+    try{
+        return fs.existsSync(fileName);
+    }catch (e) {
+        Logger.printError("WHATAP-081", "hasHostUUID error", e, false);
+        return false;
+    }
+};
+
+MeteringInfo.prototype.getHostUUID = function (fileName) {
+    const hostUUID = this.getHostUUIDValue();
+    if (hostUUID) {
+        return hostUUID;
+    }
+
+    const hasHostUUIDFile = this.hasHostUUID(fileName);
+    if (hasHostUUIDFile) {
+        try {
+            const data = fs.readFileSync(fileName, 'utf8').trim();
+            if (data && data.length > 0) {
+                this.hostUUID = data;
+                return this.hostUUID;
+            } else {
+                Logger.print('WHATAP-082', `cannot read ${fileName}`, false);
+            }
+        } catch (error) {
+            Logger.printError('WHATAP-083', `error reading ${fileName}`, error, false);
+        }
+    } else {
+        Logger.print('WHATAP-084', `cannot find ${fileName}`, false);
+    }
+    return null;
+};
+
+MeteringInfo.prototype.getHostUUIDValue = function () {
+    return this.hostUUID;
+};
+
+MeteringInfo.prototype.getCsp = function () {
+    if(process.env["ECS_CONTAINER_METADATA_URI"]) {
+        this.csp = "aws";
+        return this.csp;
+    }
+    if(Util.cloudPlatformCheck()) {
+        this.csp = "kic";
+        return this.csp;
+    }
+    return null;
+};
+
+module.exports = MeteringInfo;

package/lib/counter/task/proc-cpu.js

@@ -0,0 +1,29 @@
+/**
+ * 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'),
+    Long            = require('long');
+
+function ProcCpu() {
+    CounterTask.call(this);
+    this.oldCpu = 0;
+}
+
+ProcCpu.prototype = new CounterTask();
+ProcCpu.prototype.constructor = ProcCpu;
+ProcCpu.prototype.process = function (p) {
+    var cpu = ResourceProfile.getCPU().times; /*long*/
+    if(this.oldCpu<=0) {
+        this.oldCpu = cpu;
+        return;
+    }
+    var dTime = cpu - this.oldCpu;
+    this.oldCpu = cpu;
+    p.cputime = dTime;
+};
+
+module.exports = ProcCpu;

package/lib/counter/task/realtimeuser.js

@@ -0,0 +1,31 @@
+/**
+ * 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'),
+    MeterUser       = require('../meter/meter-users'),
+    RealTimeUserPack= require('../../pack/realtimeuser-pack'),
+    DataPackSender  = require('../../data/datapack-sender'),
+    Long            = require('long');
+
+function RealTimeUser() {
+
+}
+RealTimeUser.prototype = new CounterTask();
+RealTimeUser.prototype.constructor = RealTimeUser;
+RealTimeUser.prototype.process = function (p) {
+    var hll = MeterUser.getRealtimeUsers();
+    if(hll == null) {
+        return;
+    }
+
+    var pk = new RealTimeUserPack();
+    pk.time = p.time;
+    pk.cadinality=hll.cardinality();
+    pk.logbits = hll.getBytes();
+    DataPackSender.sendRealtimeUserPack(pk);
+};
+
+module.exports = RealTimeUser;

package/lib/counter/task/res/systemECSTask.js

@@ -0,0 +1,39 @@
+/**
+ * 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'),
+    conf = require('../../../conf/configure'),
+    SecurityMaster = require('../../../net/security-master'),
+    AwsEcsClientThread = require('./util/awsEcsClientThread');
+
+function SystemECSTask() {
+    CounterTask.call(this);
+}
+
+SystemECSTask.prototype = new CounterTask();
+SystemECSTask.prototype.constructor = SystemECSTask;
+SystemECSTask.prototype.process = function (p) {
+    p.host_ip = SecurityMaster.IP;
+
+    var ecs = AwsEcsClientThread;
+
+    setTimeout(() => {
+        p.cpu = ecs.cpu * conf.correction_factor_cpu;
+        p.cpu_sys = ecs.cpu_sys;
+        p.cpu_usr = ecs.cpu_user;
+        p.mem = ecs.mem_pct;
+
+        if (ecs.millicore > 0) {
+            p.metering = ecs.millicore / 1024;
+            p.cpu_cores = Math.ceil(p.metering);
+        } else {
+            p.metering = p.cpu_cores;
+        }
+    }, 500);
+
+};
+
+module.exports = SystemECSTask;

package/lib/counter/task/res/systemKubeTask.js

@@ -0,0 +1,53 @@
+/**
+ * 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'),
+    StatSql = require('../../../stat/stat-sql'),
+    conf = require('../../../conf/configure'),
+    ConfSysMon = require('../../../conf/conf-sys-mon'),
+    SecurityMaster = require('../../../net/security-master'),
+    TraceContextManager = require('../../../trace/trace-context-manager'),
+    MeterActiveX = require('../../meter/meter-activex'),
+    ActiveStackPack = require('../../../pack/activestack-pack'),
+    ParamPack = require('../../../pack/param-pack'),
+    EventPack = require('../../../pack/event-pack'),
+    ActiveStackStep = require('../../../step/activestack-step'),
+    DataPackSender = require('../../../data/datapack-sender'),
+    DataTextAgent = require('../../../data/datatext-agent'),
+    EventLevel  = require('../../../data/event-level'),
+    MeterUsers = require('../../meter/meter-users'),
+    KeyGen = require('../../../util/keygen'),
+    TextTypes = require('../../../lang/text-types'),
+    ResourceProfile = require('../../../util/resourceprofile'),
+    Logger          = require('../../../logger'),
+    HashUtil = require('../../../util/hashutil'),
+    KubeUtil        = require('../../../util/kube-util'),
+    KubeClient      = require('../../../kube/kube-client'),
+    DateUtil        = require('../../../util/dateutil'),
+    Long = require('long');
+
+function SystemKubeTask() {
+    CounterTask.call(this);
+
+    this.last_metering = -1;
+}
+
+SystemKubeTask.prototype = new CounterTask();
+SystemKubeTask.prototype.constructor = SystemKubeTask;
+SystemKubeTask.prototype.process = function (p) {
+    p.cpu_cores = 1;        // static one core in nodejs
+    p.host_ip = SecurityMaster.IP;
+    var now = Date.now();
+    p.cpu = 0;
+    p.mem = 0;
+    if (p.metering != 0) {
+        this.last_metering = p.metering;
+    } else {
+        p.metering = this.last_metering;
+    }
+};
+
+module.exports = SystemKubeTask;