whatap 0.5.26 → 1.0.0

package/lib/core/agent.js

@@ -6,63 +6,60 @@
 
 var os = require('os'),
     fs = require('fs'),
-    path = require('path');
+    path = require('path'),
+    child_process = require('child_process'),
+    properLock = require('proper-lockfile'),
+    crypto = require('crypto');
 
 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,
-    FileObserver     = require('../observers/file-observer').FileObserver,
-    MongoObserver    = require('../observers/mongo-observer').MongoObserver,
-    MongooseObserver = require('../observers/mongoose-observer').MongooseObserver,
+    MongoObserver    = require('../observers/mongodb-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');
 
-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');
+// 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';
 
 var NodeAgent = function(opt) {
     this._userOpt = opt;
@@ -70,7 +67,6 @@ 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;
@@ -107,179 +103,837 @@ NodeAgent.prototype.findRoot = function () {
         root = path.join(root, '..');
     }
 };
-NodeAgent.prototype.init = function(cb) {
-    var self = this;
-    if(self._initialized) {
-        return;
+
+// 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;
     }
-    self._initialized = true;
-    self.starttime = Date.now();
+};
 
-    self.findRoot();
+// 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 '';
+};
 
-    Logger.initializer.process();
+// 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;
+    }
+};
 
-    // 최초 1회 실행 후 1시간마다 실행
-    const ONE_HOUR = 60 * 60 * 1000;
-    Logger.clearOldLog();
-    setInterval(Logger.clearOldLog, ONE_HOUR);
+// Modified isGoAgentRunning to check PID +-1 range
+NodeAgent.prototype.isGoAgentRunning = function(pid) {
+    try {
+        if (!pid) return false;
 
-    Logger.print('WHATAP-001', 'Start initialize WhaTap Agent... Root[' + self._conf['app.root'] + ']', true);
+        // 원래 PID와 +1, -1된 PID 모두 확인
+        const pidsToCheck = [
+            parseInt(pid),
+            parseInt(pid) + 1,
+            parseInt(pid) - 1
+        ];
 
-    if(self._conf['app.root'] == null || self._conf['app.root'].length == 0) {
-        return Logger.print("WHATAP-001", "Can not find application root directory", true);
+        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;
     }
+};
 
-    NodeUtil.getPackageJson();
-    PackageCtrHelper.dynamicHook();
+/**
+ * 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._conf.init(this._userOpt , function(e) {
-        if(e) {
-            Logger.printError("WHATAP-002", "Configuataion initialize error. " + e.message,
-                e, true);
-            return;
+/**
+ * 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;
+    }
+};
+
+/**
+ * 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');
+
+    if (fs.existsSync(confPath)) {
+        process.env.WHATAP_HOME = parentDir;
+        return confPath;
+    }
+
+    // 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;
         }
-        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();
+        current = path.dirname(current);
+    }
+
+    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);
         }
 
-        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;
+        // Similar to Python, add a delay after 50 attempts
+        if (attempts > 50) {
+            setTimeout(() => {}, 100); // 0.1 second delay
+        }
+
+        attempts++;
+    }
+
+    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;
+        }
+    }
+    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();
+        }
+
+        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
+                }
             }
+        }
+
+        // Determine the new port number
+        const newPort = lastPortFound ? lastPortFound + 1 : port;
+
+        // Clear the file completely
+        fs.ftruncateSync(fileHandle, 0);
 
-            self.connect(function (err) {
-                if(!err) {
-                    self.initOK(cb);
+        // 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.loadObserves();
-    return this;
+                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.initOK = function(cb) {
-    var self = this;
+NodeAgent.prototype.getApplicationIdentifier = function() {
+    // 1. 명시적 그룹 지정 (환경 변수)
+    if (process.env.WHATAP_APP_GROUP) {
+        return process.env.WHATAP_APP_GROUP;
+    }
 
-    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();
-}
+    // 2. 설정 파일에서 그룹 지정
+    if (this._conf['app_group']) {
+        return this._conf['app_group'];
+    }
 
+    // 3. 자동 생성
+    const appRoot = this._conf['app.root'] || process.cwd();
+    const appName = this.getApplicationName();
 
-NodeAgent.prototype.context = function(cb) {
-    return TraceContextManager.getCurrentContext();
-}
+    const identifier = crypto
+        .createHash('md5')
+        .update(`${appRoot}:${appName}`)
+        .digest('hex')
+        .substr(0, 8);
 
-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)
+    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');
+};
+
+// 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`);
+
+    // 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.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();
+
+    // 잠금 획득 시도
+    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;
+    }
+
+    // 기존 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);
+        }
+    }
+
+    // 포트 설정 및 에이전트 시작
+    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();
         });
-    }, self.setLoopTime);
+
+        // 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) {}
+    }
 };
 
-NodeAgent.prototype.connectCB = function (cb) {
+// 프로세스 종료 시 정리 작업 개선
+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) {
     var self = this;
-    if(self.connectCount >0 && self.connectCount % 5 == 0 ) {
-        return cb(new Error());
+    if (self._initialized) {
+        return self;
     }
+    self._initialized = true;
+    self.starttime = Date.now();
 
-    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);
+    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;
 };
 
+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(ExpressObserver);
-    observes.push(FileObserver);
+    // observes.push(WsObserver);
     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);
@@ -321,31 +975,83 @@ NodeAgent.prototype.setServicePort = function (port) {
     Configuration['whatap.port'] = port || 0;
 }
 
-NodeAgent.prototype.profile = function(desc, value){
+NodeAgent.prototype.initUdp = function() {
     var self = this;
+    Logger.print('WHATAP-UDP', 'Initializing UDP connection...', false);
+
+    // Initialize the UDP session
+    UdpSession.udp(self._conf);
 
-    var ctx = TraceContextManager.getCurrentContext();
-    if(ctx == null) { return; }
+    // Initialize the async sender
+    AsyncSender.startWhatapThread();
+
+    Logger.print('WHATAP-UDP', 'UDP connection initialized', false);
+};
 
-    if( self.userProfileHash === 0){
-        self.userProfileHash = HashUtil.hashFromString('CustomProfileStep');
+/**
+ * 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();
     }
-    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;
+    if (!whatapHome) {
+        Logger.print("WHATAP-HOME", `${target} is empty`, true);
     }
-    ctx.profile.add(step);
+    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;
+
+            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 (!this.writeFile(home, home.toLowerCase(), whatapHome)) {
+        return false;
+    }
+
+    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();