whatap 1.0.2 → 1.0.3-canary.0

package/lib/udp/async_sender.js

@@ -0,0 +1,119 @@
+const udpSession = require('./udp_session');
+const PacketTypeEnum = require('./packet_type_enum');
+const PacketQueue = require('./packet_queue');
+
+const SendType = {
+    DATAS: 1,
+    RELAY: 2
+};
+
+const packetQueue = PacketQueue.getInstance();
+let initialized = false;
+let sendThread = null;
+
+/**
+ * Send a packet asynchronously
+ * @param {number} packet_type - Type of packet from PacketTypeEnum
+ * @param {object} ctx - Trace context
+ * @param {array} datas - Array of data strings to send
+ */
+function send_packet(packet_type, ctx, datas = []) {
+    _initThread();
+
+    // Deep copy the context to prevent modification
+    let copiedCtx = structuredClone(ctx);
+    if (packetQueue.full()) {
+        return;
+    }
+
+    packetQueue.put([SendType.DATAS, [packet_type, copiedCtx, datas]]);
+}
+
+/**
+ * Send relay pack data asynchronously
+ * @param {Buffer} packbytes - Bytes to send
+ */
+function send_relaypack(packbytes) {
+    _initThread();
+
+    if (packetQueue.full()) {
+        return;
+    }
+
+    packetQueue.put([SendType.RELAY, packbytes]);
+}
+
+/**
+ * Start the async processing thread
+ */
+function startWhatapThread() {
+    // If thread is already running, don't start another
+    if (sendThread) {
+        return;
+    }
+
+    // Start processing loop
+    const processQueue = () => {
+        const packet = packetQueue.get();
+
+        if (!packet) {
+            // No packet, wait and try again
+            setTimeout(processQueue, 100);
+            return;
+        }
+
+        try {
+            const [sendType, params] = packet;
+            if (sendType === SendType.DATAS) {
+                const [packet_type, ctx, datas] = params;
+                udpSession.send_packet(packet_type, ctx, datas);
+            } else if (sendType === SendType.RELAY) {
+                const packbytes = params;
+                udpSession.send_relaypack(packbytes);
+            }
+        } catch (e) {
+            console.error("Error processing queue item:", e);
+        }
+
+        // Continue processing
+        setTimeout(processQueue, 0);
+    };
+
+    // Start the processing loop
+    sendThread = setTimeout(processQueue, 0);
+    console.log("WhaTap async sender thread started");
+}
+
+/**
+ * Initialize the thread if not already initialized
+ */
+function _initThread() {
+    if (initialized) {
+        return;
+    }
+
+    // Lock used to avoid multiple initializations
+    const initLock = function() {
+        if (initialized) {
+            return;
+        }
+
+        try {
+            initialized = true;
+            startWhatapThread();
+        } catch (e) {
+            console.error("Error initializing thread:", e);
+            initialized = false;
+        }
+    };
+
+    initLock();
+}
+
+// Export functions
+module.exports = {
+    send_packet,
+    send_relaypack,
+    startWhatapThread,
+    _initThread
+};

package/lib/udp/index.js

@@ -0,0 +1,17 @@
+/**
+ * Main entry point for UDP module
+ */
+
+const PacketEnum = require('./packet_enum');
+const PacketTypeEnum = require('./packet_type_enum');
+const ParamDef = require('./param_def');
+const UdpSession = require('./udp_session');
+const AsyncSender = require('./async_sender');
+
+module.exports = {
+    PacketEnum,
+    PacketTypeEnum,
+    ParamDef,
+    UdpSession,
+    AsyncSender
+};

package/lib/udp/packet_enum.js

@@ -0,0 +1,52 @@
+class PacketEnum {
+    static get PACKET_BUFFER_SIZE() { return 48 * 1024; }
+    static get PACKET_SEND_BUFFER_SIZE() { return 64 * 1024; }
+    static get DATA_SIZE_LIMIT() { return 30 * 1024 + 1; }
+
+    static get SERVER() { return "127.0.0.1"; }
+    static get PORT() { return 6600; }
+    static get PACKET_VERSION() { return 60101; }
+
+    // PACKET_HEADER
+    static get PACKET_HEADER_TYPE_POS() { return 0; }
+    static get PACKET_HEADER_TYPE_SIZE() { return 1; }
+
+    static get PACKET_HEADER_VERSION_POS() { return 1; }
+    static get PACKET_HEADER_VERSION_SIZE() { return 4; }
+
+    static get PACKET_HEADER_LEN_POS() { return 5; }
+    static get PACKET_HEADER_LEN_SIZE() { return 4; }
+
+    // PACKET_BODY
+    static get PACKET_BODY_ID_POS() { return 9; }
+    static get PACKET_BODY_ID_SIZE() { return 8; }
+
+    static get PACKET_BODY_START_TIME_POS() { return 17; }
+    static get PACKET_BODY_START_TIME_SIZE() { return 8; }
+
+    static get PACKET_BODY_ELAPSED_POS() { return 25; }
+    static get PACKET_BODY_ELAPSED_SIZE() { return 4; }
+
+    static get PACKET_BODY_CPU_POS() { return 29; }
+    static get PACKET_BODY_CPU_SIZE() { return 8; }
+
+    static get PACKET_BODY_MEMORY_POS() { return 37; }
+    static get PACKET_BODY_MEMORY_SIZE() { return 8; }
+
+    static get PACKET_BODY_THREAD_ID_POS() { return 45; }
+    static get PACKET_BODY_THREAD_ID_SIZE() { return 8; }
+
+    static get PACKET_BODY_TRACE_DATA_POS() { return 53; }
+
+    // PACKET_SIZE
+    static get PACKET_HEADER_SIZE() {
+        return this.PACKET_HEADER_TYPE_SIZE + this.PACKET_HEADER_VERSION_SIZE + this.PACKET_HEADER_LEN_SIZE;
+    }
+
+    static get PACKET_BODY_REQUIRED_SIZE() {
+        return this.PACKET_BODY_ID_SIZE + this.PACKET_BODY_START_TIME_SIZE + this.PACKET_BODY_ELAPSED_SIZE +
+            this.PACKET_BODY_CPU_SIZE + this.PACKET_BODY_MEMORY_SIZE;
+    }
+}
+
+module.exports = PacketEnum;

package/lib/udp/packet_queue.js

@@ -0,0 +1,69 @@
+/**
+ * PacketQueue - Queue implementation for async sending packets
+ * Implemented as a singleton to ensure only one queue exists.
+ */
+
+class PacketQueue {
+    constructor(maxSize = 1000) {
+        // Singleton pattern: If instance exists, return it
+        if (PacketQueue.instance) {
+            return PacketQueue.instance;
+        }
+
+        // Initialize queue
+        this.queue = [];
+        this.maxSize = maxSize;
+
+        // Store the instance
+        PacketQueue.instance = this;
+    }
+
+    put(item) {
+        if (this.queue.length < this.maxSize) {
+            this.queue.push(item);
+            return true;
+        }
+        return false;
+    }
+
+    get() {
+        if (this.queue.length > 0) {
+            return this.queue.shift();
+        }
+        return null;
+    }
+
+    full() {
+        return this.queue.length >= this.maxSize;
+    }
+
+    empty() {
+        return this.queue.length === 0;
+    }
+
+    size() {
+        return this.queue.length;
+    }
+
+    clear() {
+        this.queue = [];
+    }
+
+    /**
+     * Get the singleton instance
+     * @param {number} maxSize - Maximum size of the queue (only used if instance doesn't exist)
+     * @returns {PacketQueue} - The singleton instance
+     */
+    static getInstance(maxSize = 1000) {
+        if (!PacketQueue.instance) {
+            PacketQueue.instance = new PacketQueue(maxSize);
+        }
+        return PacketQueue.instance;
+    }
+}
+
+// Initialize the static instance property
+PacketQueue.instance = null;
+
+// Export the class
+module.exports = PacketQueue;

package/lib/udp/packet_type_enum.js

@@ -0,0 +1,33 @@
+class PacketTypeEnum {
+    static get TX_BLANK() { return 0; }
+    static get TX_START() { return 1; }
+    static get TX_DB_CONN() { return 2; }
+    static get TX_DB_FETCH() { return 3; }
+    static get TX_SQL() { return 4; }
+    static get TX_SQL_START() { return 5; }
+    static get TX_SQL_END() { return 6; }
+
+    static get TX_HTTPC() { return 7; }
+    static get TX_HTTPC_START() { return 8; }
+    static get TX_HTTPC_END() { return 9; }
+
+    static get TX_ERROR() { return 10; }
+    static get TX_MSG() { return 11; }
+    static get TX_METHOD() { return 12; }
+
+    static get TX_SECURE_MSG() { return 13; }
+    static get TX_WEB_SOCKET() { return 16; }
+
+    static get TX_END() { return 255; }
+
+    static get TX_PARAM() { return 30; }
+    static get ACTIVE_STACK() { return 40; }
+    static get ACTIVE_STATS() { return 41; }
+    static get DBCONN_POOL() { return 42; }
+
+    static get EVENT() { return 50; }
+
+    static get RELAY_PACK() { return 244; }
+}
+
+module.exports = PacketTypeEnum;

package/lib/udp/param_def.js

@@ -0,0 +1,72 @@
+class ParamDef {
+    static get KEEPALIVE() { return 1; }
+    static get AGENT_BOOT_ENV() { return 2; }
+    static get CONFIGURE_UPDATE() { return 3; }
+    static get CONFIGURE_GET() { return 4; }
+    static get COMPO_VERSIONS() { return 5; }
+    static get THREAD_LIST() { return 7; }
+    static get THREAD_DETAIL() { return 8; }
+    static get GET_ACTIVE_STACK() { return 9; }
+    static get HEAP_HISTO() { return 10; }
+    static get LOADED_CLASS_LIST() { return 11; }
+    static get GET_ENV() { return 12; }
+    static get SYSTEM_GC() { return 13; }
+    static get SET_CONFIG() { return 14; }
+    static get OPEN_SOCKET_LIST() { return 15; }
+    static get LOADED_CLASS_DETAIL() { return 16; }
+    static get LOADED_CLASS_REDEFINE() { return 17; }
+    static get AGENT_JAR_LIST() { return 18; }
+    static get AGENT_JAR_SAVE() { return 19; }
+    static get AGENT_JAR_DELETE() { return 20; }
+    static get RESET_STRING_SENT_MARK() { return 21; }
+    static get AGENT_LOG_LIST() { return 22; }
+    static get AGENT_LOG_READ() { return 23; }
+    static get THREAD_CONTROL() { return 24; }
+    static get GET_ACTIVE_TRANSACTION_LIST() { return 25; }
+    static get GET_ACTIVE_TRANSACTION_DETAIL() { return 26; }
+    static get GET_TOPOLOGY() { return 27; }
+    static get INFRA_NET_STAT() { return 28; }
+    static get INFRA_PS_EF() { return 29; }
+    static get INFRA_DOCKER_LIST() { return 30; }
+    static get INFRA_REMOTE_CMD() { return 33; }
+    static get INFRA_PEER_LIST() { return 34; }
+    static get INFRA_AGENT_UPDATE() { return 36; }
+    static get AGENT_DUMP_LIST() { return 31; }
+    static get AGENT_DUMP_READ() { return 32; }
+    static get AGENT_STAT() { return 35; }
+    static get JVM_THREAD_DUMP() { return 37; }
+    static get JVM_HEAP_DUMP() { return 38; }
+    static get KUBENETES() { return 39; }
+    static get GET_ACTIVE_STATS() { return 40; }
+    static get GET_DBCONN_POOL() { return 41; }
+    static get MODULE_DEPENDENCY() { return 101; }
+    static get DBX_INFO() { return 201; }
+    static get DBX_SETTINGS() { return 202; }
+    static get DBX_USER_SCRIPT() { return 207; }
+    static get DBX_SCRIPT_LIST() { return 208; }
+    static get DBX_SCRIPT_SQL() { return 209; }
+    static get DBX_KILL_SESSION() { return 210; }
+    static get DBX_GET_ALERT() { return 211; }
+    static get DBX_SET_ALERT() { return 212; }
+    static get DBX_PLAN() { return 213; }
+    static get DBX_SESSION_LIST() { return 214; }
+    static get DBX_SET_CPUCORES() { return 215; }
+    static get DBX_SESSION_STAT() { return 203; }
+    static get DBX_SESSION_EVENT() { return 204; }
+    static get DBX_TOPSTAT() { return 205; }
+    static get DBX_TOPEVENT() { return 206; }
+    static get CONFIG_DBC() { return 301; }
+    static get METHOD_PERF_STAT() { return 302; }
+    static get BLOCKING_DETECT() { return 303; }
+    static get CW_INFO() { return 401; }
+    static get CW_EVENTS() { return 402; }
+    static get CW_CREDENTIAL() { return 403; }
+    static get CW_REGIONS() { return 404; }
+    static get CW_METRIC_NAMES() { return 405; }
+    static get CW_AWS_RESOURCE_IDS() { return 406; }
+    static get CW_STATISTICS() { return 407; }
+    static get CW_UNITS() { return 408; }
+    static get CW_METRICS() { return 409; }
+}
+
+module.exports = ParamDef;

package/lib/udp/udp_session.js

@@ -0,0 +1,336 @@
+/**
+ * JavaScript implementation of Python's UdpSession
+ */
+
+const dgram = require('dgram');
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+
+const PacketEnum = require('./packet_enum');
+const PacketTypeEnum = require('./packet_type_enum');
+const ParamDef = require('./param_def');
+const DataOutputX = require('../io/data-outputx');
+const TraceContextManager = require('../trace/trace-context-manager');
+const PackageCtrHelper = require('../../lib/control/packagectr-helper');
+const ActiveTransaction = require('../counter/task/activetransaction');
+const GCAction = require('../system/gc-action');
+const DataOuputX = require('../../lib/io/data-outputx');
+
+class UdpSession {
+    constructor() {
+        this.socket = null;
+        this.bufferArr = [];
+        this.threadLock = false; // Simple lock simulation
+        this.readTimeout = 5000; // 5 seconds
+        this.serverHost = PacketEnum.SERVER;
+        this.serverPort = PacketEnum.PORT;
+        this.isConnected = false; // connected-UDP 여부
+    }
+
+    /**
+     * Initialize UDP socket
+     */
+    udp(config) {
+        const self = this;
+        const conf = config || {};
+
+        // Close existing socket if open
+        if (self.socket) {
+            try {
+                self.socket.close();
+            } catch (e) {
+                console.error("Error closing UDP socket:", e);
+            }
+        }
+
+        // Create UDP socket
+        self.socket = dgram.createSocket('udp4');
+
+        // Check if Unix socket is configured
+        const whatapHome = process.env.WHATAP_HOME;
+
+        if (conf.unix_socket_enabled === true && whatapHome) {
+            // Unix socket not directly supported in Node.js dgram
+            // We'll use the regular UDP socket with the configured server and port
+            console.log("Unix socket not supported in Node.js, using UDP instead");
+        }
+
+        // Configure server info
+        self.serverHost = conf.net_udp_host || PacketEnum.SERVER;
+        self.serverPort = parseInt(conf.net_udp_port || PacketEnum.PORT);
+
+        // console.log(`UDP initialized with server ${self.serverHost}:${self.serverPort}`);
+
+        // "connected UDP" 로 전환: lsof에서 peer가 보이도록
+        self.socket.connect(self.serverPort, self.serverHost, () => {
+            self.isConnected = true;
+            // 참고: UDP라 실제 연결 성사 여부 확인 절차는 없음 (peer 고정만 됨)
+            // 필요시 ephemeral 로컬 포트를 고정하고 싶으면 bind 후 connect 실행
+            // self.socket.bind(0, '127.0.0.1', () => self.socket.connect(...));
+        });
+
+        // Set up error handling
+        self.socket.on('error', function (err) {
+            console.error("UDP socket error:", err);
+        });
+        self.socket.on('close', () => { self.isConnected = false; });
+
+        self.socket.on('message', function (msg, rinfo) {
+            self.handleMessage(msg, rinfo);
+        });
+
+        return self.socket;
+    }
+
+    /**
+     * Handle incoming UDP messages
+     */
+    handleMessage(msg, rinfo) {
+        const self = this;
+        try {
+            const received = msg.toString();
+            const parts = received.split(',');
+
+            if (parts.length >= 2) {
+                const paramId = parseInt(parts[0]);
+                const request = parts[1];
+                const extra = parts.length > 2 ? parts[2] : '';
+
+                self.handle(paramId, request, extra);
+            }
+        } catch (e) {
+            console.error("Error handling UDP message:", e);
+        }
+    }
+
+    /**
+     * Handle received requests
+     */
+    handle(paramId, request, extra) {
+        const self = this;
+        if(!paramId)
+            return;
+        
+        try {
+            let threadId = 0;
+            let pid = 0;
+
+            if (extra) {
+                const extraData = extra.replace(' ', ', ').split(', ');
+                if (extraData.length > 1) {
+                    threadId = parseInt(extraData[1]);
+                    // In Node.js there's no direct thread ID, so using PID
+                    pid = process.pid;
+                }
+            }
+
+            let data = '';
+            let datas = [String(paramId), request];
+
+            if (paramId === ParamDef.SYSTEM_GC){
+                const gcAction = new GCAction();
+                const p = gcAction.execSystemGC();
+
+                const bout = new DataOuputX();
+                bout.writePack(p, null);
+                const packbytes = bout.toByteArray();
+
+                self.send_relaypack(packbytes)
+            } else if (paramId === ParamDef.MODULE_DEPENDENCY) {
+                const dependencies = PackageCtrHelper.getDependencies();
+                // result format: "axios x.x.x, whatap x.x.x, etc x,x,x"
+                const result = Object.entries(dependencies)
+                    .map(([name, version]) => `${name} ${version}`)
+                    .join(', ');
+                datas.push(result);
+                self.send_packet(PacketTypeEnum.TX_PARAM, null, datas)
+            } else if (paramId === ParamDef.GET_ACTIVE_STATS) {
+                const stats = ActiveTransaction.getActiveStats();
+                datas = [stats.join(',')];
+                self.send_packet(PacketTypeEnum.ACTIVE_STATS, null, datas);
+            }
+            return;
+        } catch (e) {
+            console.error("Error in handle method:", e);
+        }
+    }
+
+    /**
+     * Send a packet with trace data
+     * @param {number} packet_type - Type of packet from PacketTypeEnum
+     * @param {object} ctx - Trace context
+     * @param {array} datas - Array of data strings to send
+     */
+    send_packet(packet_type, ctx, datas = []) {
+        const self = this;
+
+        try {
+            // Calculate total buffer size
+            let totalSize = 0;
+            for (let i = 0; i < self.bufferArr.length; i++) {
+                totalSize += self.bufferArr[i].length;
+            }
+
+            // Add estimated size of new data
+            let newDataSize = PacketEnum.PACKET_BODY_REQUIRED_SIZE + 1;
+            for (let i = 0; i < datas.length; i++) {
+                const data = String(datas[i]);
+                newDataSize += Buffer.byteLength(data, 'utf8') + 2; // +2 for UTF encoding length
+            }
+
+            if (totalSize + newDataSize > PacketEnum.PACKET_BUFFER_SIZE) {
+                self.send(packet_type, ctx);
+            }
+
+            if (!datas || datas.length === 0) {
+                return;
+            }
+
+            // Create packet
+            const dout = new DataOutputX();
+            var startHeaderBufferSize = dout.size();
+
+            // Write header
+            dout.writeByte(packet_type);
+            dout.writeInt(PacketEnum.PACKET_VERSION);
+            dout.writeInt(0); // Placeholder for length
+
+            const startBodyBufferSize = dout.size();
+
+            // Write body if context exists
+            if (ctx) {
+                dout.writeLong(ctx.id);
+                dout.writeLong(ctx.start_time);
+                dout.writeInt(ctx.elapsed);
+                dout.writeLong(Math.floor(Date.now() / 1000));
+                dout.writeLong(0);
+                dout.writeInt(process.pid);
+            }
+
+            // Write data with length limit check
+            let diff = PacketEnum.PACKET_BUFFER_SIZE - totalSize - (PacketEnum.PACKET_BODY_REQUIRED_SIZE + 1);
+
+            for (let i = 0; i < datas.length; i++) {
+                let data = String(datas[i]).slice(0, PacketEnum.DATA_SIZE_LIMIT);
+                diff -= (Buffer.byteLength(data, 'utf8') + 2); // Account for UTF encoding overhead
+
+                if (diff < 0) {
+                    data = ' ';
+                    console.log('message too long.');
+                }
+
+                dout.writeUTF(data);
+            }
+
+            // Update length in header
+            dout.writeToPos(
+                startHeaderBufferSize + PacketEnum.PACKET_HEADER_LEN_POS,
+                dout.size() - startBodyBufferSize
+            );
+
+            // Add to buffer array (simulating thread lock)
+            if (!self.threadLock) {
+                self.threadLock = true;
+                self.bufferArr.push(dout.toByteArray());
+                self.threadLock = false;
+
+                // Flush in certain conditions
+                if (!ctx || packet_type === PacketTypeEnum.TX_START || packet_type === PacketTypeEnum.TX_END) {
+                    self.send(packet_type, ctx);
+                }
+            }
+        } catch (e) {
+            console.error("Error sending packet:", e);
+        }
+    }
+
+    /**
+     * Send the buffered packets
+     */
+    send(packet_type, ctx) {
+        const self = this;
+
+        if (!self.socket || self.bufferArr.length === 0) {
+            return;
+        }
+
+        try {
+            // Combine all buffers
+            const sendbuf = Buffer.concat(self.bufferArr);
+
+            // Send via UDP
+            const cb = (err) => {
+                if (err) {
+                    console.error("Failed to send UDP packet:", err);
+                    // Consider reinitializing UDP connection on error
+                    self.udp();
+                }
+            };
+
+            if (self.isConnected) {
+                // connected UDP: 목적지 인자 없이 전송
+                self.socket.send(sendbuf, cb);
+            } else {
+                // fallback (미연결 상태)
+                self.socket.send(sendbuf, 0, sendbuf.length, self.serverPort, self.serverHost, cb);
+            }
+        } catch (e) {
+            console.error("Error in send method:", e);
+        } finally {
+            // Clear buffer array
+            self.bufferArr = [];
+
+            // Handle context cleanup for TX_END
+            if (packet_type === PacketTypeEnum.TX_END && ctx && ctx.id) {
+                if (ctx.id) {
+                    TraceContextManager.end(ctx.id)
+                }
+            }
+        }
+    }
+
+    /**
+     * Send relay pack data
+     */
+    send_relaypack(packbytes) {
+        const self = this;
+        const packet_type = PacketTypeEnum.RELAY_PACK;
+
+        try {
+            // Check buffer size and flush if needed
+            let totalSize = 0;
+            for (let i = 0; i < self.bufferArr.length; i++) {
+                totalSize += self.bufferArr[i].length;
+            }
+
+            if (totalSize + PacketEnum.PACKET_BODY_REQUIRED_SIZE + 1 > PacketEnum.PACKET_BUFFER_SIZE) {
+                self.send(packet_type, null);
+            }
+
+            if (!packbytes) {
+                return;
+            }
+
+            // Create packet
+            const dout = new DataOutputX();
+
+            // Write header
+            dout.writeByte(packet_type);
+            dout.writeInt(PacketEnum.PACKET_VERSION);
+            dout.writeIntBytes(packbytes);
+
+            // Add to buffer
+            if (!self.threadLock) {
+                self.threadLock = true;
+                self.bufferArr.push(dout.toByteArray());
+                self.threadLock = false;
+            }
+        } catch (e) {
+            console.error("Error sending relay pack:", e);
+        }
+    }
+}
+
+// Export a singleton instance
+module.exports = new UdpSession();