whatap 1.0.1 → 1.0.2

package/lib/core/agent.js

@@ -6,60 +6,63 @@
 
 var os = require('os'),
     fs = require('fs'),
-    path = require('path'),
-    child_process = require('child_process'),
-    properLock = require('proper-lockfile'),
-    crypto = require('crypto');
+    path = require('path');
 
 const RequestLog = require('../requestlog');
 
 var Interceptor      = require('./interceptor').Interceptor,
     HttpObserver     = require('../observers/http-observer').HttpObserver,
+    NetObserver      = require('../observers/net-observer').NetObserver,
+    ClusterObserver  = require('../observers/cluster-observer').ClusterObserver,
+    ExpressObserver  = require('../observers/express-observer').ExpressObserver,
     GlobalObserver   = require('../observers/global-observer').GlobalObserver,
     MysqlObserver    = require('../observers/mysql-observer').MysqlObserver,
     Mysql2Observer    = require('../observers/mysql2-observer').Mysql2Observer,
     MariaObserver    = require('../observers/maria-observer').MariaObserver,
     SocketioObserver = require('../observers/socket.io-observer').SocketIOObserver,
     WebsocketObserver = require('../observers/websocket-observer').WebsocketObserver,
-    // WsObserver = require('../observers/websocket-observer').WsObserver,
     ProcessObserver  = require('../observers/process-observer').ProcessObserver,
-    MongoObserver    = require('../observers/mongodb-observer').MongoObserver,
-    // MongooseObserver = require('../observers/mongoose-observer').MongooseObserver,
+    FileObserver     = require('../observers/file-observer').FileObserver,
+    MongoObserver    = require('../observers/mongo-observer').MongoObserver,
+    MongooseObserver = require('../observers/mongoose-observer').MongooseObserver,
     RedisObserver    = require('../observers/redis-observer').RedisObserver,
-    IORedisObserver    = require('../observers/ioredis-observer').IORedisObserver,
     MssqlObserver    = require('../observers/mssql-observer').MssqlObserver,
+    ThriftObserver    = require('../observers/thrift-observer').ThriftObserver,
+    PromiseObserver  = require('../observers/promise-observer').PromiseObserver,
     PgSqlObserver    = require('../observers/pgsql-observer').PgSqlObserver,
+    ScheduleObserver = require('../observers/schedule-observer').ScheduleObserver,
     // GRpcObserver     = require('../observers/grpc-observer').GRpcObserver,
     ApolloObserver   = require('../observers/apollo-server-observer').ApolloServerObserver,
     PrismaObserver  = require('../observers/prisma-observer').PrismaObserver,
     OracleObserver  = require('../observers/oracle-observer').OracleObserver;
 
 
+
 var Configuration    = require('./../conf/configure'),
     SecurityMaster   = require('./../net/security-master'),
+    TcpSession       = require('./../net/tcp-session'),
+    PackageCtrHelper = require('./../control/packagectr-helper'),
+    DataPackSender   = require('../data/datapack-sender'),
     CounterManager   = require('./../counter/counter-manager'),
     NodeUtil         = require('./../util/nodeutil'),
     DateUtil         = require('./../util/dateutil'),
     WhatapUtil       = require('./../util'),
+    ParamPack        = require('../pack/param-pack').ParamPack,
+    PluginLoaderManager = require('../plugin/plugin-loadermanager'),
     TraceContextManager = require('../trace/trace-context-manager'),
+    DataTextAgent    = require('../data/datatext-agent').agent,
+    TextTypes       = require('../lang/text-types'),
     HashUtil            = require('../util/hashutil'),
+    MessageStep         = require('../step/message-step'),
     Logger           = require('../logger');
 
-// Import UDP module
-const UdpModule = require('../udp');
-const UdpSession = UdpModule.UdpSession;
-const AsyncSender = UdpModule.AsyncSender;
-const PacketTypeEnum = UdpModule.PacketTypeEnum;
-
-const ARCH = {
-    'x64': 'amd64',
-    'ia32': '386',
-    'arm': 'arm',
-    'arm64': 'arm64'
-};
-
-// Agent binary name
-const AGENT_NAME = 'whatap_nodejs';
+require('../stat/stat-tranx');
+require('../stat/stat-sql');
+require('../stat/stat-httpc');
+require('../stat/stat-remote-ip');
+require('../stat/stat-remote-ipurl');
+require('../stat/stat-useragent');
+require('../stat/timingsender');
 
 var NodeAgent = function(opt) {
     this._userOpt = opt;
@@ -67,6 +70,7 @@ var NodeAgent = function(opt) {
     this.aop = new Interceptor(this);
     this._conf = Configuration;
     this._securityMaster = SecurityMaster;
+    this._tcpsession = null;
     this._counterManager = null;
     this.setLoopTime = 5000;
     this.connectCount = 0;
@@ -103,837 +107,179 @@ NodeAgent.prototype.findRoot = function () {
         root = path.join(root, '..');
     }
 };
-
-// Cross-platform function to check if a process is running and is whatap_nodejs
-NodeAgent.prototype.isNodejsAgentProcess = function(pid) {
-    try {
-        pid = parseInt(pid);
-        const platform = process.platform;
-        let processCommand = '';
-
-        if (platform === 'linux') {
-            // On Linux, use /proc filesystem - same approach as Python
-            try {
-                const cmdlineFile = path.join('/proc', pid.toString(), 'cmdline');
-                if (fs.existsSync(cmdlineFile)) {
-                    processCommand = fs.readFileSync(cmdlineFile, 'utf8');
-                    // Log for debugging
-                    Logger.print("WHATAP-PROCESS", `Process ${pid} command line: ${processCommand}`, false);
-                }
-            } catch (e) {
-                Logger.printError("WHATAP-101", "Error reading Linux process info", e, false);
-                return false;
-            }
-        } else if (platform === 'darwin') {
-            // On macOS, use ps command
-            try {
-                processCommand = child_process.execSync(`ps -p ${pid} -o command=`, { encoding: 'utf8' }).trim();
-                Logger.print("WHATAP-PROCESS", `Process ${pid} command line: ${processCommand}`, false);
-            } catch (e) {
-                Logger.printError("WHATAP-102", "Error reading MacOS process info", e, false);
-                return false;
-            }
-        } else if (platform === 'win32') {
-            // On Windows, use tasklist command
-            try {
-                const output = child_process.execSync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`, { encoding: 'utf8' });
-                // Windows output has quotes, e.g.: "whatap_nodejs.exe","1234","Console","1","12,345 K"
-                const match = output.match(/"([^"]+)"/);
-                if (match && match[1]) {
-                    processCommand = match[1];
-                    Logger.print("WHATAP-PROCESS", `Process ${pid} command line: ${processCommand}`, false);
-                }
-            } catch (e) {
-                Logger.printError("WHATAP-103", "Error reading Windows process info", e, false);
-                return false;
-            }
-        } else {
-            // On other platforms, try generic ps command
-            try {
-                processCommand = child_process.execSync(`ps -p ${pid} -o command=`, { encoding: 'utf8' }).trim();
-                Logger.print("WHATAP-PROCESS", `Process ${pid} command line: ${processCommand}`, false);
-            } catch (e) {
-                Logger.printError("WHATAP-104", "Error reading other os process info", e, false);
-                return false;
-            }
-        }
-
-        // Check if the command contains the agent name (equivalent to Python's find('whatap_python') >= 0)
-        const isAgentProcess = processCommand.indexOf(AGENT_NAME) >= 0;
-        Logger.print("WHATAP-PROCESS", `Process ${pid} is ${isAgentProcess ? '' : 'not '}a WhaTap agent`, false);
-        return isAgentProcess;
-    } catch (e) {
-        Logger.printError("WHATAP-AGENT", "Error in isNodejsAgentProcess", e, false);
-        return false;
-    }
-};
-
-// Function to read PID from file
-NodeAgent.prototype.readPidFile = function(home, fileName) {
-    try {
-        const filePath = path.join(process.env[home], fileName);
-        if (fs.existsSync(filePath)) {
-            return fs.readFileSync(filePath, 'utf8').trim();
-        }
-    } catch (e) {
-        Logger.printError("WHATAP-PID", "Error reading PID file", e, false);
-    }
-    return '';
-};
-
-// Function to write to file
-NodeAgent.prototype.writeToFile = function(home, fileName, value) {
-    try {
-        const filePath = path.join(process.env[home], fileName);
-        fs.writeFileSync(filePath, value);
-        return true;
-    } catch (e) {
-        Logger.printError("WHATAP-FILE", `Error writing to file ${fileName}`, e, false);
-        Logger.print("WHATAP-FILE", `Try to execute command: \`sudo chmod -R 777 $WHATAP_HOME\``, false);
-        return false;
-    }
-};
-
-// Modified isGoAgentRunning to check PID +-1 range
-NodeAgent.prototype.isGoAgentRunning = function(pid) {
-    try {
-        if (!pid) return false;
-
-        // 원래 PID와 +1, -1된 PID 모두 확인
-        const pidsToCheck = [
-            parseInt(pid),
-            parseInt(pid) + 1,
-            parseInt(pid) - 1
-        ];
-
-        Logger.print("WHATAP-AGENT", `Checking PIDs: ${pidsToCheck.join(', ')} (original: ${pid})`, false);
-
-        for (const pidToCheck of pidsToCheck) {
-            try {
-                // 프로세스 존재 여부 확인
-                process.kill(pidToCheck, 0);
-
-                // whatap_nodejs 프로세스인지 확인
-                if (this.isNodejsAgentProcess(pidToCheck)) {
-                    Logger.print("WHATAP-AGENT",
-                        `Found agent process at PID ${pidToCheck} (original PID in file: ${pid})`,
-                        false);
-                    return true;
-                }
-            } catch (e) {
-                // ESRCH error means process doesn't exist
-                if (e.code !== 'ESRCH') {
-                    throw e;
-                }
-            }
-        }
-
-        Logger.print("WHATAP-AGENT", `No agent process found for PID ${pid} or adjacent PIDs`, false);
-        return false;
-    } catch (e) {
-        Logger.printError("WHATAP-AGENT", "Error checking if agent is running", e, false);
-        return false;
+NodeAgent.prototype.init = function(cb) {
+    var self = this;
+    if(self._initialized) {
+        return;
     }
-};
+    self._initialized = true;
+    self.starttime = Date.now();
 
-/**
- * Read content from a file - similar to Python's read_file
- * @param {string} home - Environment variable name for home directory
- * @param {string} fileName - Name of the file to read
- * @returns {string} - Content of the file, or empty string on error
- */
-NodeAgent.prototype.readFile = function(home, fileName) {
-    try {
-        const filePath = path.join(process.env[home], fileName);
-        if (fs.existsSync(filePath)) {
-            return fs.readFileSync(filePath, 'utf8').toString().trim();
-        }
-    } catch (e) {
-        Logger.printError("WHATAP-FILE", `Error reading file ${fileName}`, e, false);
-    }
-    return '';
-};
+    self.findRoot();
 
-/**
- * Write content to a file - similar to Python's write_file
- * @param {string} home - Environment variable name for home directory
- * @param {string} fileName - Name of the file to write
- * @param {string} value - Content to write to the file
- * @returns {boolean} - True if successful, false otherwise
- */
-NodeAgent.prototype.writeFile = function(home, fileName, value) {
-    try {
-        const filePath = path.join(process.env[home], fileName);
-        fs.writeFileSync(filePath, value);
-        return true;
-    } catch (e) {
-        Logger.printError("WHATAP-FILE", `Error writing to file ${fileName}`, e, false);
-        Logger.print("WHATAP-FILE", `Try to execute command: \`sudo chmod -R 777 $WHATAP_HOME\``, false);
-        return false;
-    }
-};
+    Logger.initializer.process();
 
-/**
- * Find whatap.conf file by searching directories - similar to Python's find_whatap_conf
- * @returns {string|null} - Path to whatap.conf or null if not found
- */
-NodeAgent.prototype.findWhatapConf = function() {
-    // 1. Check current directory
-    const scriptDir = path.dirname(__filename);
-    const parentDir = path.dirname(scriptDir);
-    let confPath = path.join(parentDir, 'whatap.conf');
+    // 최초 1회 실행 후 1시간마다 실행
+    const ONE_HOUR = 60 * 60 * 1000;
+    Logger.clearOldLog();
+    setInterval(Logger.clearOldLog, ONE_HOUR);
 
-    if (fs.existsSync(confPath)) {
-        process.env.WHATAP_HOME = parentDir;
-        return confPath;
-    }
+    Logger.print('WHATAP-001', 'Start initialize WhaTap Agent... Root[' + self._conf['app.root'] + ']', true);
 
-    // 2. Check parent directories
-    let current = parentDir;
-    while (current !== '/' && current !== path.parse(current).root) {
-        confPath = path.join(current, 'whatap.conf');
-        if (fs.existsSync(confPath)) {
-            process.env.WHATAP_HOME = current;
-            return confPath;
-        }
-        current = path.dirname(current);
+    if(self._conf['app.root'] == null || self._conf['app.root'].length == 0) {
+        return Logger.print("WHATAP-001", "Can not find application root directory", true);
     }
 
-    return null;
-};
-
-/**
- * Open and lock the port file - similar to Python's openPortFile
- * @param {string} filepath - Path to the lock file
- * @returns {object|null} - File descriptor or null if failed
- */
-NodeAgent.prototype.openPortFile = function(filepath) {
-    filepath = filepath || process.env.WHATAP_LOCK_FILE || '/tmp/whatap-nodejs.lock';
-
-    let fileHandle = null;
-    let attempts = 0;
-
-    // Try to open the file, similar to Python's while loop
-    while (!fileHandle && attempts < 100) {
-        try {
-            // Try to open file for reading and writing
-            if (fs.existsSync(filepath)) {
-                fileHandle = fs.openSync(filepath, 'r+');
-            } else {
-                // If file doesn't exist, create the directory if needed
-                const dirPath = path.dirname(filepath);
-                if (!fs.existsSync(dirPath)) {
-                    fs.mkdirSync(dirPath, { recursive: true });
-                }
-                // Create the file
-                fileHandle = fs.openSync(filepath, 'w+');
-            }
-        } catch (e) {
-            Logger.printError("WHATAP-PORT", `Error opening port file (attempt ${attempts})`, e, false);
-        }
-
-        // Similar to Python, add a delay after 50 attempts
-        if (attempts > 50) {
-            setTimeout(() => {}, 100); // 0.1 second delay
-        }
-
-        attempts++;
-    }
+    NodeUtil.getPackageJson();
+    PackageCtrHelper.dynamicHook();
 
-    if (fileHandle) {
-        try {
-            // Use proper-lock with the filepath instead of file descriptor
-            properLock.lockSync(filepath);
-            return { fileHandle, filepath };
-        } catch (e) {
-            Logger.printError("WHATAP-PORT", "Failed to lock port file", e, false);
-            try {
-                fs.closeSync(fileHandle);
-            } catch (closeErr) {}
-            return null;
+    self._conf.init(this._userOpt , function(e) {
+        if(e) {
+            Logger.printError("WHATAP-002", "Configuataion initialize error. " + e.message,
+                e, true);
+            return;
         }
-    }
-    return null;
-};
-
-/**
- * Get available port number for the agent - similar to Python's get_port_number
- * @param {number} defaultPort - Default port to start with
- * @param {string} home - WHATAP_HOME directory
- * @returns {number|null} - Allocated port number or null if failed
- */
-NodeAgent.prototype.getPortNumber = function(port, home) {
-    port = port || 6600;
-    home = home || process.env.WHATAP_HOME;
-
-    // Return null if home is not defined
-    if (!home) {
-        return null;
-    }
-
-    // Open the port file
-    const fileInfo = this.openPortFile();
-    if (!fileInfo) {
-        return port; // Return default port if we couldn't open the file
-    }
-
-    const { fileHandle, filepath } = fileInfo;
-
-    try {
-        // Get file size
-        const stats = fs.fstatSync(fileHandle);
-        let content = '';
-
-        // Only read if file is not empty
-        if (stats.size > 0) {
-            const buffer = Buffer.alloc(stats.size);
-            fs.readSync(fileHandle, buffer, 0, buffer.length, 0);
-            content = buffer.toString().trim();
+        Logger.print('WHATAP-101', 'Finish initialize configuration... ' + Boolean(self._conf['reqlog_enabled']) , false);
+        if(Boolean(self._conf['reqlog_enabled']) == true ) {
+            Logger.print("WHATAP-REQLOG" , "ReqLog Init Start !!!! " , false);
+            RequestLog.initializer.process();
         }
 
-        let lastPortFound = null;
-
-        // Process each line
-        if (content && content.length > 0) {
-            const lines = content.split('\n');
-            for (const line of lines) {
-                const trimmedLine = line.trim();
-                if (!trimmedLine) continue;
-
-                try {
-                    // Parse the line "port home"
-                    const parts = trimmedLine.split(/\s+/, 2);
-                    if (parts.length < 2) continue;
-
-                    const portStr = parts[0];
-                    const portHome = parts[1];
-                    const currentPort = parseInt(portStr, 10);
-
-                    if (isNaN(currentPort)) continue;
-
-                    // If home matches, return the port
-                    if (home === portHome) {
-                        // Clean up before returning
-                        properLock.unlockSync(filepath);
-                        fs.closeSync(fileHandle);
-                        return currentPort;
-                    }
-
-                    // Track the highest port number
-                    if (!lastPortFound || lastPortFound < currentPort) {
-                        lastPortFound = currentPort;
-                    }
-                } catch (e) {
-                    continue; // Skip lines that can't be parsed
-                }
+        self._securityMaster.run( function (err) {
+            if(err) {
+                Logger.printError('WHATAP-104', 'Failed to connect to whatap server', err, false);
+                if(self._counterManager) self._counterManager.stop();
+                return;
             }
-        }
-
-        // Determine the new port number
-        const newPort = lastPortFound ? lastPortFound + 1 : port;
-
-        // Clear the file completely
-        fs.ftruncateSync(fileHandle, 0);
 
-        // Write the new entry directly
-        fs.writeSync(fileHandle, `${newPort}\t${home}\n`);
-
-        // Unlock and close the file
-        properLock.unlockSync(filepath);
-        fs.closeSync(fileHandle);
-
-        return newPort;
-    } catch (e) {
-        Logger.printError("WHATAP-PORT", "Error processing port file", e, false);
-
-        try {
-            properLock.unlockSync(filepath);
-            fs.closeSync(fileHandle);
-        } catch (closeErr) {
-        }
-
-        return port;
-    }
-};
-
-/**
- * Configure the port for the agent and update the configuration
- * @returns {number|null} - The configured port or null if failed
- */
-NodeAgent.prototype.configurePort = function() {
-    const port = this.getPortNumber();
-    if (port) {
-        this.updateConfig('WHATAP_HOME', 'net_udp_port', port.toString());
-        return port;
-    }
-    return null;
-};
-
-/**
- * Update configuration file with new option value - similar to Python's update_config
- * @param {string} home - Environment variable name for WhaTap home
- * @param {string} optKey - Option key to update
- * @param {string} optValue - Option value to set
- */
-NodeAgent.prototype.updateConfig = function(home, optKey, optValue) {
-    const homePath = process.env[home];
-    if (!homePath) {
-        Logger.print("WHATAP-CONFIG", `${home} environment variable not set`, true);
-        return;
-    }
-
-    const configFile = path.join(homePath, 'whatap.conf');
-
-    try {
-        let content = '';
-        let isUpdated = false;
-
-        if (fs.existsSync(configFile)) {
-            const lines = fs.readFileSync(configFile, 'utf8').split('\n');
-
-            // Look for the option key and update if found
-            for (let line of lines) {
-                if (line.trim()) {
-                    const parts = line.split('=');
-                    const key = parts[0].trim();
-
-                    if (key === optKey) {
-                        line = `${key}=${optValue}`;
-                        isUpdated = true;
-                    }
+            self.connect(function (err) {
+                if(!err) {
+                    self.initOK(cb);
                 }
-                content += line + '\n';
-            }
-
-            // If the option wasn't found, add it
-            if (!isUpdated) {
-                content += `\n${optKey}=${optValue}\n`;
-            }
-        } else {
-            // If config file doesn't exist, create with just this option
-            content = `${optKey}=${optValue}\n`;
-        }
-
-        // Write updated content back to file
-        fs.writeFileSync(configFile, content);
-        Logger.print("WHATAP-CONFIG", `Updated configuration: ${optKey}=${optValue}`, false);
-    } catch (e) {
-        Logger.printError("WHATAP-CONFIG", `Error updating configuration: ${optKey}=${optValue}`, e, false);
-    }
-};
-
-NodeAgent.prototype.getApplicationIdentifier = function() {
-    // 1. 명시적 그룹 지정 (환경 변수)
-    if (process.env.WHATAP_APP_GROUP) {
-        return process.env.WHATAP_APP_GROUP;
-    }
-
-    // 2. 설정 파일에서 그룹 지정
-    if (this._conf['app_group']) {
-        return this._conf['app_group'];
-    }
-
-    // 3. 자동 생성
-    const appRoot = this._conf['app.root'] || process.cwd();
-    const appName = this.getApplicationName();
-
-    const identifier = crypto
-        .createHash('md5')
-        .update(`${appRoot}:${appName}`)
-        .digest('hex')
-        .substr(0, 8);
-
-    Logger.print("WHATAP-AGENT",
-        `Application identifier: ${appName} at ${appRoot} => ${identifier}`,
-        false);
-
-    return identifier;
-};
-
-NodeAgent.prototype.getApplicationName = function() {
-    // 1. PM2 실행 시
-    if (process.env.PM2_APP_NAME || process.env.name) {
-        return process.env.PM2_APP_NAME || process.env.name;
-    }
-
-    // 2. 설정 파일에서
-    if (this._conf['app_name']) {
-        return this._conf['app_name'];
-    }
-
-    // 3. 명령행 인수에서 --name 옵션 찾기
-    const nameArgIndex = process.argv.indexOf('--name');
-    if (nameArgIndex !== -1 && nameArgIndex < process.argv.length - 1) {
-        return process.argv[nameArgIndex + 1];
-    }
-
-    // 4. 환경 변수로 직접 설정
-    if (process.env.APP_NAME) {
-        return process.env.APP_NAME;
-    }
-
-    // 5. 기본값: 실행 파일명
-    return path.basename(process.argv[1], '.js');
+            });
+        });
+    });
+    self.loadObserves();
+    return this;
 };
 
-// startGoAgent with improved PID handling
-NodeAgent.prototype.startGoAgent = function(opts = {}) {
-    const self = this;
-    const home = 'WHATAP_HOME';
-    const pidFileName = `${AGENT_NAME}.pid`;
-    const whatapHome = process.env[home];
-
-    if (!whatapHome) {
-        Logger.printError("WHATAP-105", "WHATAP_HOME environment variable is not set", true);
-        return;
-    }
-
-    // 1. 애플리케이션 식별자 생성 (포트 제외)
-    const appIdentifier = this.getApplicationIdentifier();
-    const sharedLockFile = path.join(whatapHome, `agent-${appIdentifier}.lock`);
-    const sharedPidFile = path.join(whatapHome, `agent-${appIdentifier}.pid`);
+NodeAgent.prototype.initOK = function(cb) {
+    var self = this;
 
-    // 2. 공유 잠금 파일을 사용하여 중복 실행 방지
-    try {
-        if (fs.existsSync(sharedPidFile)) {
-            // PID 파일에서 기존 PID 읽기
-            const existingPid = fs.readFileSync(sharedPidFile, 'utf8').trim();
-            if (existingPid && this.isGoAgentRunning(existingPid)) {
-                Logger.print("WHATAP-AGENT", `Go agent already running for application ${appIdentifier} (PID: ${existingPid})`, false);
-                return;
-            } else {
-                // 프로세스가 죽었다면 파일 제거
-                Logger.print("WHATAP-AGENT", `Previous agent process ${existingPid} not found, cleaning up`, false);
-                try { fs.unlinkSync(sharedLockFile); } catch (e) {}
-                try { fs.unlinkSync(sharedPidFile); } catch (e) {}
-            }
-        }
-    } catch (e) {
-        Logger.printError("WHATAP-AGENT", "Error checking shared lock file", e, false);
-    }
+    Logger.ONAME = self._securityMaster.ONAME;
+    Logger.initializer.reset();
+
+    TraceContextManager.initialized = true;
+    DataTextAgent.reset();
+
+    var param = new ParamPack();
+    param.putString("whatap.version", NodeUtil.getVersion()+' '+ NodeUtil.getReleaseDate());
+    param.putString("os.name", os.platform());
+    param.putString("os.arch", os.arch());
+    param.putString('os.release', os.release());
+    param.putString('node.version', process.version);
+    param.putString('node.uptime', (new Date()).toString());
+    param.putString('node.name', NodeUtil.getName());
+    param.putString('user.timezone', NodeUtil.getTimeZone());
+    param.putString('user.home', os.homedir());
+    param.putString('user.hostname', os.hostname());
+    // CLOUD PLATFORM INFO
+    param.putString('CLOUD_PLATFORM', WhatapUtil.cloudPlatformCheck());
+    DataPackSender.sendBoot(param);
+
+    if(self._counterManager === null) {
+        self._counterManager = new CounterManager(self);
+        self._counterManager.run();
+        PluginLoaderManager.start();
+    }
+
+    WhatapUtil.printWhatap();
+    self.connectCount = 0;
+    self.setLoopTime = 5000;
+    if(cb) cb();
+}
 
-    // 잠금 획득 시도
-    let lockAcquired = false;
-    try {
-        if (!fs.existsSync(sharedLockFile)) {
-            fs.writeFileSync(sharedLockFile, process.pid.toString());
-            lockAcquired = true;
-        }
-    } catch (e) {
-        Logger.printError("WHATAP-AGENT", "Error acquiring lock", e, false);
-    }
 
-    if (!lockAcquired) {
-        Logger.print("WHATAP-AGENT", "Another process is starting the agent, waiting...", false);
-        return;
-    }
+NodeAgent.prototype.context = function(cb) {
+    return TraceContextManager.getCurrentContext();
+}
 
-    // 기존 whatap_nodejs.pid 파일 처리 (호환성 유지)
-    const pid = this.readPidFile(home, pidFileName);
-    if (pid) {
-        try {
-            if (this.isGoAgentRunning(pid)) {
-                Logger.print("WHATAP-106", `Found existing agent with PID ${pid}, terminating...`, false);
-                try {
-                    process.kill(parseInt(pid), 'SIGKILL');
-                    Logger.print("WHATAP-107", `Successfully terminated existing agent with PID ${pid}`, false);
-                } catch (killError) {
-                    Logger.printError("WHATAP-108", `Error terminating process with PID ${pid}`, killError, false);
-                }
-            }
-        } catch (e) {
-            Logger.printError("WHATAP-109", `Error checking process with PID ${pid}`, e, false);
+NodeAgent.prototype.connect = function (cb) {
+    var self = this;
+    if(self.connectCount >0 && self.connectCount % 10 == 0 ) {
+        Logger.print("WHATAP-171",
+            "[WhaTap Agent] Can not find server port.\n" +
+            "Did you add requre('whatap') as the first line of the app's main module?\n" +
+            "https://service.whatap.io/project/" + self._securityMaster.PCODE + "/install",
+            true);
+        if(self.setLoopTime == 5000) {
+            self.setLoopTime += 25000;
+            Logger.print("WHATAP-150", "[WhaTap Agent] setLoopTime Up -> " + self.setLoopTime , false)
+        }else if(self.setLoopTime == 30000) {
+            self.setLoopTime += 30000;
+            Logger.print("WHATAP-150", "[WhaTap Agent] setLoopTime Up -> " + self.setLoopTime , false)
+        } else if(self.setLoopTime == 60000) {
+            self.setLoopTime += 300000;
+            Logger.print("WHATAP-150", "[WhaTap Agent] setLoopTime Up -> " + self.setLoopTime , false)
         }
     }
-
-    // 포트 설정 및 에이전트 시작
-    const port = this.configurePort();
-    if (!port) {
-        Logger.printError("WHATAP-AGENT", "Failed to configure UDP port for agent", null, true);
-        try { fs.unlinkSync(sharedLockFile); } catch (e) {}
-        return;
-    }
-    Logger.print("WHATAP-AGENT", `Configured agent to use UDP port: ${port}`, false);
-
-    try {
-        // 바이너리 경로 설정
-        const agentPath = path.join(whatapHome, AGENT_NAME);
-        const platform = process.platform;
-        const architecture = ARCH[process.arch] || process.arch;
-        const sourcePath = path.join(__dirname, '..', '..', 'agent', platform, architecture, AGENT_NAME);
-
-        // 심볼릭 링크 생성
-        if (!fs.existsSync(agentPath)) {
-            try {
-                fs.symlinkSync(sourcePath, agentPath);
-                Logger.print("WHATAP-AGENT", `Created symbolic link for ${AGENT_NAME}`, false);
-            } catch (e) {
-                if (e.code !== 'EEXIST') {
-                    if (platform === 'win32') {
-                        Logger.print("WHATAP-AGENT", "Symlink failed, copying binary instead", false);
-                        fs.copyFileSync(sourcePath, agentPath);
-                    } else {
-                        throw e;
-                    }
-                }
-            }
-        }
-
-        // run 디렉토리 생성
-        const sockfilePath = path.join(whatapHome, 'run');
-        if (!fs.existsSync(sockfilePath)) {
-            fs.mkdirSync(sockfilePath, { recursive: true });
-        }
-
-        // 환경 변수 설정
-        const newEnv = Object.assign({}, process.env);
-        newEnv['whatap.start'] = Date.now().toString();
-        newEnv['node.uptime'] = new Date().toString();
-        newEnv['node.version'] = process.version;
-        newEnv['node.tzname'] = new Date().toLocaleString('en', {timeZoneName: 'short'}).split(' ').pop();
-        newEnv['os.release'] = os.release();
-        newEnv['whatap.enabled'] = 'True';
-        newEnv['WHATAP_PID_FILE'] = sharedPidFile; // 공유 PID 파일 사용
-        newEnv['NODEJS_PARENT_APP_PID'] = process.pid.toString();
-        newEnv['net_udp_port'] = port.toString();
-        newEnv['APP_IDENTIFIER'] = appIdentifier;
-        newEnv['APP_NAME'] = this.getApplicationName();
-
-        // PM2 정보 추가
-        const isPM2 = typeof process.env.PM2_HOME !== 'undefined' ||
-            typeof process.env.pm_id !== 'undefined' ||
-            typeof process.env.PM2_JSON_PROCESSING !== 'undefined';
-
-        if (isPM2) {
-            newEnv['PM2_APP_NAME'] = process.env.name || '';
-            newEnv['PM2_ID'] = process.env.pm_id || '';
-        }
-
-        Object.assign(newEnv, opts);
-
-        // 에이전트 프로세스 시작
-        const agentProcess = child_process.spawn(
-            agentPath,
-            ['-t', '2', '-d', '1'],
-            {
-                cwd: whatapHome,
-                env: newEnv,
-                stdio: ['pipe', 'pipe', 'pipe'],
-                detached: true
-            }
-        );
-
-        let stdout = '';
-        let stderr = '';
-
-        agentProcess.stdout.on('data', (data) => {
-            stdout += data.toString();
-        });
-
-        agentProcess.stderr.on('data', (data) => {
-            stderr += data.toString();
+    Logger.print("WHATAP-170", "[WhaTap Agent] now waiting for starting......", false)
+    self._tcpsession = TcpSession;
+    setTimeout(function () {
+        Logger.print("WHATAP-011" , "Connecton Retry....")
+        self.connectCount++;
+        self._tcpsession.open(function(err) {
+            if(err) {
+                Logger.printError("WHTAP-11", "TCP SESSION OPEN ERROR", err ,false);
+                return self.connect(cb);
+            };
+            if(cb) cb();
         });
-
-        // PID 추적을 위한 추가 로직
-        agentProcess.on('spawn', () => {
-            Logger.print("WHATAP-AGENT", `Agent process spawned with PID: ${agentProcess.pid}`, false);
-
-            // detached 프로세스에서 실제 PID가 다를 수 있으므로 잠시 대기 후 확인
-            setTimeout(() => {
-                try {
-                    // ps 명령으로 실제 PID 찾기
-                    const psCommand = process.platform === 'win32'
-                        ? `tasklist /FI "IMAGENAME eq ${AGENT_NAME}*" /FO CSV /NH`
-                        : `ps -ef | grep ${AGENT_NAME} | grep -v grep`;
-
-                    const psOutput = child_process.execSync(psCommand, { encoding: 'utf8' });
-                    const lines = psOutput.trim().split('\n');
-
-                    for (const line of lines) {
-                        let foundPid = null;
-
-                        if (process.platform === 'win32') {
-                            // Windows CSV format: "image","pid","session","#","mem"
-                            const match = line.match(/"[^"]+","(\d+)"/);
-                            if (match) foundPid = match[1];
-                        } else {
-                            // Unix format: uid pid ppid ...
-                            const parts = line.split(/\s+/);
-                            if (parts.length > 1) foundPid = parts[1];
-                        }
-
-                        if (foundPid) {
-                            const pidNum = parseInt(foundPid);
-                            // spawn된 PID와 비슷한 범위인지 확인
-                            if (Math.abs(pidNum - agentProcess.pid) <= 2) {
-                                Logger.print("WHATAP-AGENT",
-                                    `Found actual agent PID: ${foundPid} (spawn returned: ${agentProcess.pid})`,
-                                    false);
-
-                                // 실제 PID로 파일 업데이트
-                                fs.writeFileSync(sharedPidFile, foundPid);
-                                this.writeToFile(home, pidFileName, foundPid);
-                                return;
-                            }
-                        }
-                    }
-
-                    // 실제 PID를 찾지 못한 경우 spawn이 반환한 PID 사용
-                    Logger.print("WHATAP-AGENT",
-                        `Using spawn PID: ${agentProcess.pid} (actual PID not found)`,
-                        false);
-
-                    fs.writeFileSync(sharedPidFile, agentProcess.pid.toString());
-                    this.writeToFile(home, pidFileName, agentProcess.pid.toString());
-
-                } catch (e) {
-                    Logger.printError("WHATAP-AGENT", "Error finding actual PID", e, false);
-                    // 에러 발생 시 spawn이 반환한 PID 사용
-                    fs.writeFileSync(sharedPidFile, agentProcess.pid.toString());
-                    this.writeToFile(home, pidFileName, agentProcess.pid.toString());
-                }
-            }, 1000); // 1초 대기
-        });
-
-        agentProcess.on('close', (code) => {
-            if (code !== 0) {
-                Logger.printError("WHATAP-AGENT", `Agent process exited with code ${code}`, null, true);
-                Logger.print("WHATAP-AGENT", `STDOUT: ${stdout}`, false);
-                Logger.print("WHATAP-AGENT", `STDERR: ${stderr}`, false);
-                // 에이전트가 비정상 종료되면 파일 제거
-                try { fs.unlinkSync(sharedLockFile); } catch (e) {}
-                try { fs.unlinkSync(sharedPidFile); } catch (e) {}
-            } else {
-                Logger.print("WHATAP-AGENT", "Agent started successfully", false);
-            }
-        });
-
-        agentProcess.unref();
-
-        Logger.print("WHATAP-AGENT",
-            `AGENT UP! (process name: ${AGENT_NAME}, using port: ${port}, app: ${appIdentifier})`,
-            false);
-
-        // 잠금 해제
-        try { fs.unlinkSync(sharedLockFile); } catch (e) {}
-
-    } catch (e) {
-        Logger.printError("WHATAP-AGENT", "Error starting agent", e, true);
-        // 에러 발생 시 파일 정리
-        try { fs.unlinkSync(sharedLockFile); } catch (e) {}
-        try { fs.unlinkSync(sharedPidFile); } catch (e) {}
-    }
+    }, self.setLoopTime);
 };
 
-// 프로세스 종료 시 정리 작업 개선
-process.on('exit', () => {
-    if (!process.env.WHATAP_HOME || !NodeAgent.prototype.getApplicationIdentifier) {
-        return;
-    }
-
-    try {
-        const appIdentifier = NodeAgent.prototype.getApplicationIdentifier.call(NodeAgent);
-        const sharedPidFile = path.join(process.env.WHATAP_HOME, `agent-${appIdentifier}.pid`);
-
-        if (fs.existsSync(sharedPidFile)) {
-            const pid = fs.readFileSync(sharedPidFile, 'utf8').trim();
-            // 현재 프로세스가 기록된 PID의 부모 프로세스인 경우에만 제거
-            if (pid === process.env.NODEJS_PARENT_APP_PID) {
-                fs.unlinkSync(sharedPidFile);
-            }
-        }
-    } catch (e) {
-        // 에러 무시
-    }
-});
-
-// graceful shutdown 처리 추가
-['SIGTERM', 'SIGINT'].forEach((signal) => {
-    process.on(signal, () => {
-        Logger.print("WHATAP-AGENT", `Received ${signal}, cleaning up...`, false);
-        process.exit(0);
-    });
-});
-
-// Updated init method to incorporate configuration setup similar to Python agent
-NodeAgent.prototype.init = function(cb) {
+NodeAgent.prototype.connectCB = function (cb) {
     var self = this;
-    if (self._initialized) {
-        return self;
+    if(self.connectCount >0 && self.connectCount % 5 == 0 ) {
+        return cb(new Error());
     }
-    self._initialized = true;
-    self.starttime = Date.now();
-
-    self.findRoot();
-
-    Logger.initializer.process();
-    Logger.print('WHATAP-110', 'Start initialize WhaTap Agent... Root[' + self._conf['app.root'] + ']', true);
-
-    if (self._conf['app.root'] == null || self._conf['app.root'].length == 0) {
-        return Logger.print("WHATAP-111", "Can not find application root directory", true);
-    }
-
-    // Initialize configuration with proper home directory
-    if (!self.initConfig('WHATAP_HOME')) {
-        Logger.printError("WHATAP-CONFIG", "Failed to initialize configuration", null, true);
-        return self;
-    }
-
-    NodeUtil.getPackageJson();
-
-    self._conf.init(this._userOpt, function(e) {
-        if (e) {
-            Logger.printError("WHATAP-112", "Configuration initialize error. " + e.message,
-                e, true);
-            return;
-        }
-        Logger.print('WHATAP-113', 'Finish initialize configuration... ' + Boolean(self._conf['reqlog_enabled']), false);
-        if (Boolean(self._conf['reqlog_enabled']) == true) {
-            Logger.print("WHATAP-REQLOG", "ReqLog Init Start !!!!", false);
-            RequestLog.initializer.process();
-        }
-
-        if(!self._counterManager){
-            self._counterManager = new CounterManager();
-            self._counterManager.run();
-        }
-
-        // Set Oname,Oid
-        self._securityMaster.decideAgentOnameOid();
 
-        // Start Node.js agent with proper port configuration
-        WhatapUtil.printWhatap();
-        self.startGoAgent();
-        TraceContextManager.initialized = true;
-
-        self.initUdp();
-    });
-
-    self.loadObserves();
-    return self;
+    Logger.print("WHATAP-970", "[WhaTap Agent] now waiting for starting......", true)
+    self._tcpsession = TcpSession;
+    setTimeout(function () {
+        self._tcpsession.open(function(err) {
+            if(err) {
+                Logger.printError("WHTAP-911", "TCP SESSION OPEN ERROR", err ,true);
+                self.connectCB(cb);
+                return;
+            };
+            if(cb) cb();
+        });
+    }, self.setLoopTime);
 };
 
-NodeAgent.prototype.context = function(cb) {
-    return TraceContextManager.getCurrentContext();
-}
-
 NodeAgent.prototype.loadObserves = function() {
     var agent = this;
     var observes = [];
 
     observes.push(HttpObserver);
+    observes.push(NetObserver);
+    observes.push(ClusterObserver);
     observes.push(MysqlObserver);
     observes.push(Mysql2Observer);
     observes.push(MariaObserver);
     observes.push(SocketioObserver);
     observes.push(WebsocketObserver);
-    // observes.push(WsObserver);
+    observes.push(ExpressObserver);
+    observes.push(FileObserver);
     observes.push(MongoObserver);
-    // observes.push(MongooseObserver);
+    observes.push(MongooseObserver);
     observes.push(RedisObserver);
-    observes.push(IORedisObserver);
     observes.push(MssqlObserver);
+    observes.push(ThriftObserver);
+    observes.push(PromiseObserver);
     observes.push(PgSqlObserver);
+    observes.push(ScheduleObserver);
     // observes.push(GRpcObserver);
     observes.push(ApolloObserver);
     observes.push(PrismaObserver);
@@ -975,83 +321,31 @@ NodeAgent.prototype.setServicePort = function (port) {
     Configuration['whatap.port'] = port || 0;
 }
 
-NodeAgent.prototype.initUdp = function() {
+NodeAgent.prototype.profile = function(desc, value){
     var self = this;
-    Logger.print('WHATAP-UDP', 'Initializing UDP connection...', false);
-
-    // Initialize the UDP session
-    UdpSession.udp(self._conf);
-
-    // Initialize the async sender
-    AsyncSender.startWhatapThread();
-
-    Logger.print('WHATAP-UDP', 'UDP connection initialized', false);
-};
-
-/**
- * Check if WHATAP_HOME is set - similar to Python's check_whatap_home
- * @param {string} target - Environment variable name to check
- * @returns {string|null} - Value of the environment variable or null
- */
-NodeAgent.prototype.checkWhatapHome = function(target) {
-    let whatapHome = process.env[target];
-    if (!whatapHome) {
-        whatapHome = this.findWhatapConf();
-    }
-    if (!whatapHome) {
-        Logger.print("WHATAP-HOME", `${target} is empty`, true);
-    }
-    return whatapHome;
-};
 
-/**
- * Initialize configuration with default values - similar to Python's init_config
- * @param {string} home - Environment variable name for home directory
- * @returns {boolean} - True if successful, false otherwise
- */
-NodeAgent.prototype.initConfig = function(home) {
-    let whatapHome = process.env[home];
-    if (!whatapHome) {
-        whatapHome = this.findWhatapConf();
-    }
-    if (!whatapHome) {
-        whatapHome = this.readFile(home, home.toLowerCase());
-        if (!whatapHome) {
-            whatapHome = process.cwd();
-            process.env[home] = whatapHome;
+    var ctx = TraceContextManager.getCurrentContext();
+    if(ctx == null) { return; }
 
-            Logger.print("WHATAP-HOME", "WHATAP_HOME is empty", true);
-            Logger.print("WHATAP-HOME", "WHATAP_HOME set default CURRENT_WORKING_DIRECTORY value", true);
-            Logger.print("WHATAP-HOME", `CURRENT_WORKING_DIRECTORY is ${whatapHome}`, true);
-        }
+    if( self.userProfileHash === 0){
+        self.userProfileHash = HashUtil.hashFromString('CustomProfileStep');
     }
-
-    if (!this.writeFile(home, home.toLowerCase(), whatapHome)) {
-        return false;
+    DataTextAgent.add(TextTypes.MESSAGE,self.userProfileHash, 'CustomProfileStep');
+    var step = new MessageStep();
+    step.hash = self.userProfileHash;
+    step.start_time = ctx.getElapsedTime();
+    step.desc = desc;
+    if(value){
+        step.value=false;
     }
+    ctx.profile.add(step);
 
-    process.env[home] = whatapHome;
-    const configFile = path.join(process.env[home], 'whatap.conf');
-
-    if (!fs.existsSync(configFile)) {
-        try {
-            // Copy default config from module directory
-            const defaultConfigPath = path.join(path.dirname(__dirname), 'whatap.conf');
-            if (fs.existsSync(defaultConfigPath)) {
-                const content = fs.readFileSync(defaultConfigPath, 'utf8');
-                fs.writeFileSync(configFile, content);
-            } else {
-                // Create empty config file
-                fs.writeFileSync(configFile, '# WhaTap Node.js Agent Configuration\n');
-            }
-        } catch (e) {
-            Logger.printError("WHATAP-CONFIG", "Permission error creating config file", e, true);
-            Logger.print("WHATAP-CONFIG", 'Try to execute command: `sudo chmod -R 777 $WHATAP_HOME`', true);
-            return false;
-        }
-    }
-
-    return true;
-};
-
+}
+// var plugins={};
+// NodeAgent.prototype.plugin = function(name, func){
+//     if(func){
+//         plugins[name]=func;
+//     }
+//     return plugins[name];
+// } 
 exports.NodeAgent = new NodeAgent();