whatap 1.0.3 → 1.0.4

package/lib/core/agent.js

@@ -32,7 +32,8 @@ var Interceptor      = require('./interceptor').Interceptor,
     // 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;
+    OracleObserver  = require('../observers/oracle-observer').OracleObserver,
+    CustomMethodObserver = require('../observers/custom-method-observer').CustomMethodObserver;
 
 
 var Configuration    = require('./../conf/configure'),
@@ -112,13 +113,13 @@ NodeAgent.prototype.isNodejsAgentProcess = function(pid) {
         let processCommand = '';
 
         if (platform === 'linux') {
-            // On Linux, use /proc filesystem - same approach as Python
+            // On Linux, use /proc filesystem
             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);
+                    Logger.print("WHATAP-001", `Process ${pid} command line: ${processCommand}`, false);
                 }
             } catch (e) {
                 Logger.printError("WHATAP-101", "Error reading Linux process info", e, false);
@@ -128,7 +129,7 @@ NodeAgent.prototype.isNodejsAgentProcess = function(pid) {
             // 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);
+                Logger.print("WHATAP-001", `Process ${pid} command line: ${processCommand}`, false);
             } catch (e) {
                 Logger.printError("WHATAP-102", "Error reading MacOS process info", e, false);
                 return false;
@@ -141,7 +142,7 @@ NodeAgent.prototype.isNodejsAgentProcess = function(pid) {
                 const match = output.match(/"([^"]+)"/);
                 if (match && match[1]) {
                     processCommand = match[1];
-                    Logger.print("WHATAP-PROCESS", `Process ${pid} command line: ${processCommand}`, false);
+                    Logger.print("WHATAP-001", `Process ${pid} command line: ${processCommand}`, false);
                 }
             } catch (e) {
                 Logger.printError("WHATAP-103", "Error reading Windows process info", e, false);
@@ -151,19 +152,19 @@ NodeAgent.prototype.isNodejsAgentProcess = function(pid) {
             // 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);
+                Logger.print("WHATAP-001", `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)
+        // Check if the command contains the agent name
         const isAgentProcess = processCommand.indexOf(AGENT_NAME) >= 0;
-        Logger.print("WHATAP-PROCESS", `Process ${pid} is ${isAgentProcess ? '' : 'not '}a WhaTap agent`, false);
+        Logger.print("WHATAP-002", `Process ${pid} is ${isAgentProcess ? '' : 'not '}a WhaTap agent`, false);
         return isAgentProcess;
     } catch (e) {
-        Logger.printError("WHATAP-AGENT", "Error in isNodejsAgentProcess", e, false);
+        Logger.printError("WHATAP-003", "Error in isNodejsAgentProcess", e, false);
         return false;
     }
 };
@@ -176,7 +177,7 @@ NodeAgent.prototype.readPidFile = function(home, fileName) {
             return fs.readFileSync(filePath, 'utf8').trim();
         }
     } catch (e) {
-        Logger.printError("WHATAP-PID", "Error reading PID file", e, false);
+        Logger.printError("WHATAP-004", "Error reading PID file", e, false);
     }
     return '';
 };
@@ -188,8 +189,8 @@ NodeAgent.prototype.writeToFile = function(home, fileName, value) {
         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);
+        Logger.printError("WHATAP-005", `Error writing to file ${fileName}`, e, false);
+        Logger.print("WHATAP-006", `Try to execute command: \`sudo chmod -R 777 $WHATAP_HOME\``, false);
         return false;
     }
 };
@@ -206,7 +207,7 @@ NodeAgent.prototype.isGoAgentRunning = function(pid) {
             parseInt(pid) - 1
         ];
 
-        Logger.print("WHATAP-AGENT", `Checking PIDs: ${pidsToCheck.join(', ')} (original: ${pid})`, false);
+        Logger.print("WHATAP-007", `Checking PIDs: ${pidsToCheck.join(', ')} (original: ${pid})`, false);
 
         for (const pidToCheck of pidsToCheck) {
             try {
@@ -215,7 +216,7 @@ NodeAgent.prototype.isGoAgentRunning = function(pid) {
 
                 // whatap_nodejs 프로세스인지 확인
                 if (this.isNodejsAgentProcess(pidToCheck)) {
-                    Logger.print("WHATAP-AGENT",
+                    Logger.print("WHATAP-008",
                         `Found agent process at PID ${pidToCheck} (original PID in file: ${pid})`,
                         false);
                     return true;
@@ -228,16 +229,16 @@ NodeAgent.prototype.isGoAgentRunning = function(pid) {
             }
         }
 
-        Logger.print("WHATAP-AGENT", `No agent process found for PID ${pid} or adjacent PIDs`, false);
+        Logger.print("WHATAP-009", `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);
+        Logger.printError("WHATAP-010", "Error checking if agent is running", e, false);
         return false;
     }
 };
 
 /**
- * Read content from a file - similar to Python's read_file
+ * Read content from a 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
@@ -249,13 +250,13 @@ NodeAgent.prototype.readFile = function(home, fileName) {
             return fs.readFileSync(filePath, 'utf8').toString().trim();
         }
     } catch (e) {
-        Logger.printError("WHATAP-FILE", `Error reading file ${fileName}`, e, false);
+        Logger.printError("WHATAP-011", `Error reading file ${fileName}`, e, false);
     }
     return '';
 };
 
 /**
- * Write content to a file - similar to Python's write_file
+ * Write content to a 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
@@ -267,14 +268,14 @@ NodeAgent.prototype.writeFile = function(home, fileName, value) {
         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);
+        Logger.printError("WHATAP-012", `Error writing to file ${fileName}`, e, false);
+        Logger.print("WHATAP-013", `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
+ * Find whatap.conf file by searching directories
  * @returns {string|null} - Path to whatap.conf or null if not found
  */
 NodeAgent.prototype.findWhatapConf = function() {
@@ -303,7 +304,7 @@ NodeAgent.prototype.findWhatapConf = function() {
 };
 
 /**
- * Open and lock the port file - similar to Python's openPortFile
+ * Open and lock the port file
  * @param {string} filepath - Path to the lock file
  * @returns {object|null} - File descriptor or null if failed
  */
@@ -313,7 +314,7 @@ NodeAgent.prototype.openPortFile = function(filepath) {
     let fileHandle = null;
     let attempts = 0;
 
-    // Try to open the file, similar to Python's while loop
+    // Try to open the file
     while (!fileHandle && attempts < 100) {
         try {
             // Try to open file for reading and writing
@@ -329,10 +330,10 @@ NodeAgent.prototype.openPortFile = function(filepath) {
                 fileHandle = fs.openSync(filepath, 'w+');
             }
         } catch (e) {
-            Logger.printError("WHATAP-PORT", `Error opening port file (attempt ${attempts})`, e, false);
+            Logger.printError("WHATAP-014", `Error opening port file (attempt ${attempts})`, e, false);
         }
 
-        // Similar to Python, add a delay after 50 attempts
+        // Add a delay after 50 attempts
         if (attempts > 50) {
             setTimeout(() => {}, 100); // 0.1 second delay
         }
@@ -346,7 +347,7 @@ NodeAgent.prototype.openPortFile = function(filepath) {
             properLock.lockSync(filepath);
             return { fileHandle, filepath };
         } catch (e) {
-            Logger.printError("WHATAP-PORT", "Failed to lock port file", e, false);
+            Logger.printError("WHATAP-015", "Failed to lock port file", e, false);
             try {
                 fs.closeSync(fileHandle);
             } catch (closeErr) {}
@@ -357,7 +358,7 @@ NodeAgent.prototype.openPortFile = function(filepath) {
 };
 
 /**
- * Get available port number for the agent - similar to Python's get_port_number
+ * Get available port number for the agent
  * @param {number} defaultPort - Default port to start with
  * @param {string} home - WHATAP_HOME directory
  * @returns {number|null} - Allocated port number or null if failed
@@ -371,8 +372,33 @@ NodeAgent.prototype.getPortNumber = function(port, home) {
         return null;
     }
 
-    // Open the port file
-    const fileInfo = this.openPortFile();
+    // PM2 cluster 모드에서는 pm_id를 제외한 identifier 사용 (동일 포트 공유)
+    // 일반 모드에서는 pm_id 포함 (각자 다른 포트)
+    const appIdentifier = this.getApplicationIdentifier();
+    const portKey = `${home}:${appIdentifier}`;
+    const isPM2Cluster = this.isPM2ClusterMode();
+
+    const lockFilePath = process.env.WHATAP_LOCK_FILE || '/tmp/whatap-nodejs.lock';
+
+    // PM2 cluster 모드에서 whatap_nodejs가 이미 실행 중이면 lock 없이 읽기만
+    if (isPM2Cluster) {
+        const sharedPidFile = path.join(home, `agent-${appIdentifier}.pid`);
+        if (fs.existsSync(sharedPidFile)) {
+            try {
+                const existingPid = fs.readFileSync(sharedPidFile, 'utf8').trim();
+                if (existingPid && this.isGoAgentRunning(existingPid)) {
+                    // whatap_nodejs가 실행 중이면 lock 없이 포트 파일 읽기
+                    return this.readPortFromFile(lockFilePath, portKey, appIdentifier, isPM2Cluster);
+                }
+            } catch (e) {
+                Logger.printError("WHATAP-016", "Error checking agent process", e, false);
+            }
+        }
+    }
+
+    // 새로운 포트 할당이 필요한 경우 (첫 실행 또는 일반 모드)
+    // Open the port file with lock
+    const fileInfo = this.openPortFile(lockFilePath);
     if (!fileInfo) {
         return port; // Return default port if we couldn't open the file
     }
@@ -392,6 +418,7 @@ NodeAgent.prototype.getPortNumber = function(port, home) {
         }
 
         let lastPortFound = null;
+        const existingPorts = new Map();
 
         // Process each line
         if (content && content.length > 0) {
@@ -401,24 +428,30 @@ NodeAgent.prototype.getPortNumber = function(port, home) {
                 if (!trimmedLine) continue;
 
                 try {
-                    // Parse the line "port home"
-                    const parts = trimmedLine.split(/\s+/, 2);
+                    // Parse the line "port portKey"
+                    const parts = trimmedLine.split(/\t/, 2);
                     if (parts.length < 2) continue;
 
                     const portStr = parts[0];
-                    const portHome = parts[1];
+                    const storedKey = parts[1];
                     const currentPort = parseInt(portStr, 10);
 
                     if (isNaN(currentPort)) continue;
 
-                    // If home matches, return the port
-                    if (home === portHome) {
+                    // If portKey matches, return the existing port
+                    if (portKey === storedKey) {
                         // Clean up before returning
                         properLock.unlockSync(filepath);
                         fs.closeSync(fileHandle);
+                        Logger.print("WHATAP-017",
+                            `Reusing existing port ${currentPort} for ${appIdentifier}${isPM2Cluster ? ' (PM2 cluster - shared port)' : ''}`,
+                            false);
                         return currentPort;
                     }
 
+                    // Store existing ports
+                    existingPorts.set(storedKey, currentPort);
+
                     // Track the highest port number
                     if (!lastPortFound || lastPortFound < currentPort) {
                         lastPortFound = currentPort;
@@ -432,19 +465,27 @@ NodeAgent.prototype.getPortNumber = function(port, home) {
         // Determine the new port number
         const newPort = lastPortFound ? lastPortFound + 1 : port;
 
-        // Clear the file completely
-        fs.ftruncateSync(fileHandle, 0);
+        // Rebuild the file with existing entries + new entry
+        let newContent = '';
+        for (const [key, portNum] of existingPorts.entries()) {
+            newContent += `${portNum}\t${key}\n`;
+        }
+        newContent += `${newPort}\t${portKey}\n`;
 
-        // Write the new entry directly
-        fs.writeSync(fileHandle, `${newPort}\t${home}\n`);
+        // Clear and rewrite the file
+        fs.ftruncateSync(fileHandle, 0);
+        fs.writeSync(fileHandle, newContent);
 
         // Unlock and close the file
         properLock.unlockSync(filepath);
         fs.closeSync(fileHandle);
 
+        Logger.print("WHATAP-018",
+            `Allocated new port ${newPort} for ${appIdentifier}${isPM2Cluster ? ' (PM2 cluster - shared port)' : ''}`,
+            false);
         return newPort;
     } catch (e) {
-        Logger.printError("WHATAP-PORT", "Error processing port file", e, false);
+        Logger.printError("WHATAP-019", "Error processing port file", e, false);
 
         try {
             properLock.unlockSync(filepath);
@@ -456,6 +497,56 @@ NodeAgent.prototype.getPortNumber = function(port, home) {
     }
 };
 
+/**
+ * Read port from file without acquiring lock (for PM2 cluster mode)
+ * @param {string} filepath - Port file path
+ * @param {string} portKey - Port key to search
+ * @param {string} appIdentifier - Application identifier
+ * @param {boolean} isPM2Cluster - Whether in PM2 cluster mode
+ * @returns {number|null} - Port number or null if not found
+ */
+NodeAgent.prototype.readPortFromFile = function(filepath, portKey, appIdentifier, isPM2Cluster) {
+    try {
+        if (!fs.existsSync(filepath)) {
+            Logger.printError("WHATAP-020", "Port file does not exist", null, false);
+            return null;
+        }
+
+        const content = fs.readFileSync(filepath, 'utf8').trim();
+
+        if (!content) {
+            return null;
+        }
+
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmedLine = line.trim();
+            if (!trimmedLine) continue;
+
+            const parts = trimmedLine.split(/\t/, 2);
+            if (parts.length < 2) continue;
+
+            const portStr = parts[0];
+            const storedKey = parts[1];
+            const currentPort = parseInt(portStr, 10);
+
+            if (isNaN(currentPort)) continue;
+
+            if (portKey === storedKey) {
+                Logger.print("WHATAP-021",
+                    `Reusing existing port ${currentPort} for ${appIdentifier}${isPM2Cluster ? ' (PM2 cluster - shared port, lock-free read)' : ''}`,
+                    false);
+                return currentPort;
+            }
+        }
+
+        return null;
+    } catch (e) {
+        Logger.printError("WHATAP-022", "Error reading port file without lock", e, false);
+        return null;
+    }
+};
+
 /**
  * Configure the port for the agent and update the configuration
  * @returns {number|null} - The configured port or null if failed
@@ -470,7 +561,7 @@ NodeAgent.prototype.configurePort = function() {
 };
 
 /**
- * Update configuration file with new option value - similar to Python's update_config
+ * Update configuration file with new option value
  * @param {string} home - Environment variable name for WhaTap home
  * @param {string} optKey - Option key to update
  * @param {string} optValue - Option value to set
@@ -478,11 +569,13 @@ NodeAgent.prototype.configurePort = function() {
 NodeAgent.prototype.updateConfig = function(home, optKey, optValue) {
     const homePath = process.env[home];
     if (!homePath) {
-        Logger.print("WHATAP-CONFIG", `${home} environment variable not set`, true);
+        Logger.print("WHATAP-023", `${home} environment variable not set`, false);
         return;
     }
 
-    const configFile = path.join(homePath, 'whatap.conf');
+    // Use WHATAP_CONF environment variable or default to 'whatap.conf'
+    const configFileName = process.env.WHATAP_CONF || 'whatap.conf';
+    const configFile = path.join(homePath, configFileName);
 
     try {
         let content = '';
@@ -516,12 +609,22 @@ NodeAgent.prototype.updateConfig = function(home, optKey, optValue) {
 
         // Write updated content back to file
         fs.writeFileSync(configFile, content);
-        Logger.print("WHATAP-CONFIG", `Updated configuration: ${optKey}=${optValue}`, false);
+        Logger.print("WHATAP-024", `Updated configuration: ${optKey}=${optValue}`, false);
     } catch (e) {
-        Logger.printError("WHATAP-CONFIG", `Error updating configuration: ${optKey}=${optValue}`, e, false);
+        Logger.printError("WHATAP-025", `Error updating configuration: ${optKey}=${optValue}`, e, false);
     }
 };
 
+/**
+ * Check if running in PM2 cluster mode
+ * @returns {boolean} - True if PM2 cluster mode
+ */
+NodeAgent.prototype.isPM2ClusterMode = function() {
+    return process.env.pm_id !== undefined &&
+        process.env.instances !== undefined &&
+        parseInt(process.env.instances) > 1;
+};
+
 NodeAgent.prototype.getApplicationIdentifier = function() {
     // 1. 명시적 그룹 지정 (환경 변수)
     if (process.env.WHATAP_APP_GROUP) {
@@ -536,24 +639,35 @@ NodeAgent.prototype.getApplicationIdentifier = function() {
     // 3. 자동 생성
     const appRoot = this._conf['app.root'] || process.cwd();
     const appName = this.getApplicationName();
+    const isPM2Cluster = this.isPM2ClusterMode();
+
+    // PM2 cluster 모드에서는 pm_id를 제외하여 모든 인스턴스가 동일한 identifier를 공유
+    // 일반 PM2 모드나 단일 인스턴스에서는 pm_id 포함
+    let identifierBase = `${appRoot}:${appName}`;
+    if (process.env.pm_id !== undefined && !isPM2Cluster) {
+        identifierBase += `:${process.env.pm_id}`;
+    }
 
     const identifier = crypto
         .createHash('md5')
-        .update(`${appRoot}:${appName}`)
+        .update(identifierBase)
         .digest('hex')
         .substr(0, 8);
 
-    Logger.print("WHATAP-AGENT",
-        `Application identifier: ${appName} at ${appRoot} => ${identifier}`,
+    Logger.print("WHATAP-026",
+        `Application identifier: ${appName} at ${appRoot}${isPM2Cluster ? ' (PM2 cluster mode)' : (process.env.pm_id !== undefined ? ' (PM2 instance: ' + process.env.pm_id + ')' : '')} => ${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;
+    // 1. PM2 실행 시 (PM2의 공식 환경 변수 사용)
+    if (process.env.pm_id !== undefined) {
+        // PM2 환경에서는 name 환경 변수 사용
+        if (process.env.name) {
+            return process.env.name;
+        }
     }
 
     // 2. 설정 파일에서
@@ -588,8 +702,9 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
         return;
     }
 
-    // 1. 애플리케이션 식별자 생성 (포트 제외)
+    // 1. 애플리케이션 식별자 생성
     const appIdentifier = this.getApplicationIdentifier();
+    const isPM2Cluster = this.isPM2ClusterMode();
     const sharedLockFile = path.join(whatapHome, `agent-${appIdentifier}.lock`);
     const sharedPidFile = path.join(whatapHome, `agent-${appIdentifier}.pid`);
 
@@ -599,33 +714,64 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
             // 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);
+                const logMsg = isPM2Cluster
+                    ? `Go agent already running for application ${appIdentifier} (PID: ${existingPid}) - PM2 instance ${process.env.pm_id} will connect to shared agent`
+                    : `Go agent already running for application ${appIdentifier} (PID: ${existingPid})`;
+                Logger.print("WHATAP-027", logMsg, false);
                 return;
             } else {
                 // 프로세스가 죽었다면 파일 제거
-                Logger.print("WHATAP-AGENT", `Previous agent process ${existingPid} not found, cleaning up`, false);
+                Logger.print("WHATAP-028", `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.printError("WHATAP-029", "Error checking shared lock file", e, false);
     }
 
-    // 잠금 획득 시도
-    let lockAcquired = false;
-    try {
-        if (!fs.existsSync(sharedLockFile)) {
-            fs.writeFileSync(sharedLockFile, process.pid.toString());
-            lockAcquired = true;
+    // 3. PM2 cluster 모드에서는 첫 번째 인스턴스만 에이전트 시작
+    if (isPM2Cluster) {
+        // 잠금 파일로 동시 실행 방지
+        let lockAcquired = false;
+        try {
+            if (!fs.existsSync(sharedLockFile)) {
+                fs.writeFileSync(sharedLockFile, process.pid.toString());
+                lockAcquired = true;
+                Logger.print("WHATAP-030",
+                    `PM2 cluster mode: Instance ${process.env.pm_id} will start shared agent`,
+                    false);
+            } else {
+                // 다른 인스턴스가 이미 에이전트를 시작하는 중
+                Logger.print("WHATAP-031",
+                    `PM2 cluster mode: Instance ${process.env.pm_id} detected another instance starting the agent, will use shared agent`,
+                    false);
+                return;
+            }
+        } catch (e) {
+            Logger.printError("WHATAP-032", "Error acquiring lock in PM2 cluster mode", e, false);
+            return;
         }
-    } 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;
+        if (!lockAcquired) {
+            return;
+        }
+    } else {
+        // 일반 모드에서는 기존 로직 사용
+        let lockAcquired = false;
+        try {
+            if (!fs.existsSync(sharedLockFile)) {
+                fs.writeFileSync(sharedLockFile, process.pid.toString());
+                lockAcquired = true;
+            }
+        } catch (e) {
+            Logger.printError("WHATAP-033", "Error acquiring lock", e, false);
+        }
+
+        if (!lockAcquired) {
+            Logger.print("WHATAP-034", "Another process is starting the agent, waiting...", false);
+            return;
+        }
     }
 
     // 기존 whatap_nodejs.pid 파일 처리 (호환성 유지)
@@ -647,7 +793,7 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
     }
 
     // 포트 설정은 initUdp()에서 처리됨
-    Logger.print("WHATAP-AGENT", "Port configuration will be handled during UDP initialization", false);
+    Logger.print("WHATAP-035", "Port configuration will be handled during UDP initialization", false);
 
     try {
         // 바이너리 경로 설정
@@ -660,11 +806,11 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
         if (!fs.existsSync(agentPath)) {
             try {
                 fs.symlinkSync(sourcePath, agentPath);
-                Logger.print("WHATAP-AGENT", `Created symbolic link for ${AGENT_NAME}`, false);
+                Logger.print("WHATAP-036", `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);
+                        Logger.print("WHATAP-037", "Symlink failed, copying binary instead", false);
                         fs.copyFileSync(sourcePath, agentPath);
                     } else {
                         throw e;
@@ -686,20 +832,34 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
         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.enabled'] = 'true';
         newEnv['WHATAP_PID_FILE'] = sharedPidFile; // 공유 PID 파일 사용
-        newEnv['NODEJS_PARENT_APP_PID'] = process.pid.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';
+        const isPM2 = process.env.pm_id !== undefined;
 
         if (isPM2) {
             newEnv['PM2_APP_NAME'] = process.env.name || '';
-            newEnv['PM2_ID'] = process.env.pm_id || '';
+            newEnv['PM2_INSTANCES'] = process.env.instances || '1';
+
+            // PM2 cluster 모드
+            if (isPM2Cluster) {
+                // cluster 모드에서는 첫 번째 인스턴스의 ID만 전달
+                newEnv['PM2_CLUSTER_MODE'] = 'true';
+                newEnv['PM2_STARTER_ID'] = process.env.pm_id || '0';
+                Logger.print("WHATAP-038",
+                    `PM2 cluster mode: Starting shared agent from instance ${process.env.pm_id}`,
+                    false);
+            } else {
+                // 단일 인스턴스 모드
+                newEnv['PM2_ID'] = process.env.pm_id || '';
+                newEnv['NODEJS_PARENT_APP_PID'] = process.pid.toString();
+            }
+        } else {
+            // PM2가 아닌 경우
+            newEnv['NODEJS_PARENT_APP_PID'] = process.pid.toString();
         }
 
         Object.assign(newEnv, opts);
@@ -729,7 +889,7 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
 
         // PID 추적을 위한 추가 로직
         agentProcess.on('spawn', () => {
-            Logger.print("WHATAP-AGENT", `Agent process spawned with PID: ${agentProcess.pid}`, false);
+            Logger.print("WHATAP-039", `Agent process spawned with PID: ${agentProcess.pid}`, false);
 
             // detached 프로세스에서 실제 PID가 다를 수 있으므로 잠시 대기 후 확인
             setTimeout(() => {
@@ -759,7 +919,7 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
                             const pidNum = parseInt(foundPid);
                             // spawn된 PID와 비슷한 범위인지 확인
                             if (Math.abs(pidNum - agentProcess.pid) <= 2) {
-                                Logger.print("WHATAP-AGENT",
+                                Logger.print("WHATAP-040",
                                     `Found actual agent PID: ${foundPid} (spawn returned: ${agentProcess.pid})`,
                                     false);
 
@@ -772,7 +932,7 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
                     }
 
                     // 실제 PID를 찾지 못한 경우 spawn이 반환한 PID 사용
-                    Logger.print("WHATAP-AGENT",
+                    Logger.print("WHATAP-041",
                         `Using spawn PID: ${agentProcess.pid} (actual PID not found)`,
                         false);
 
@@ -780,7 +940,7 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
                     this.writeToFile(home, pidFileName, agentProcess.pid.toString());
 
                 } catch (e) {
-                    Logger.printError("WHATAP-AGENT", "Error finding actual PID", e, false);
+                    Logger.printError("WHATAP-042", "Error finding actual PID", e, false);
                     // 에러 발생 시 spawn이 반환한 PID 사용
                     fs.writeFileSync(sharedPidFile, agentProcess.pid.toString());
                     this.writeToFile(home, pidFileName, agentProcess.pid.toString());
@@ -790,28 +950,29 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
 
         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);
+                Logger.printError("WHATAP-043", `Agent process exited with code ${code}`, null, false);
+                Logger.print("WHATAP-044", `STDOUT: ${stdout}`, false);
+                Logger.print("WHATAP-045", `STDERR: ${stderr}`, false);
                 // 에이전트가 비정상 종료되면 파일 제거
                 try { fs.unlinkSync(sharedLockFile); } catch (e) {}
                 try { fs.unlinkSync(sharedPidFile); } catch (e) {}
             } else {
-                Logger.print("WHATAP-AGENT", "Agent started successfully", false);
+                Logger.print("WHATAP-046", "Agent started successfully", false);
             }
         });
 
         agentProcess.unref();
 
-        Logger.print("WHATAP-AGENT",
-            `AGENT UP! (process name: ${AGENT_NAME}, app: ${appIdentifier})`,
-            false);
+        const agentMsg = isPM2Cluster
+            ? `AGENT UP! (process name: ${AGENT_NAME}, app: ${appIdentifier}, PM2 cluster - shared by ${process.env.instances} instances)`
+            : `AGENT UP! (process name: ${AGENT_NAME}, app: ${appIdentifier})`;
+        Logger.print("WHATAP-047", agentMsg, false);
 
         // 잠금 해제
         try { fs.unlinkSync(sharedLockFile); } catch (e) {}
 
     } catch (e) {
-        Logger.printError("WHATAP-AGENT", "Error starting agent", e, true);
+        Logger.printError("WHATAP-048", "Error starting agent", e, false);
         // 에러 발생 시 파일 정리
         try { fs.unlinkSync(sharedLockFile); } catch (e) {}
         try { fs.unlinkSync(sharedPidFile); } catch (e) {}
@@ -820,11 +981,23 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
 
 // 프로세스 종료 시 정리 작업 개선
 process.on('exit', () => {
-    if (!process.env.WHATAP_HOME || !NodeAgent.prototype.getApplicationIdentifier) {
+    if (!process.env.WHATAP_HOME || !NodeAgent.prototype.getApplicationIdentifier || !NodeAgent.prototype.isPM2ClusterMode) {
         return;
     }
 
     try {
+        const isPM2Cluster = NodeAgent.prototype.isPM2ClusterMode.call(NodeAgent);
+
+        // PM2 cluster 모드에서는 인스턴스가 종료되어도 공유 에이전트를 종료하지 않음
+        // 다른 인스턴스가 계속 사용 중일 수 있음
+        if (isPM2Cluster) {
+            Logger.print("WHATAP-049",
+                `PM2 cluster instance ${process.env.pm_id} exiting - shared agent will remain running`,
+                false);
+            return;
+        }
+
+        // 일반 모드에서는 기존 로직 사용
         const appIdentifier = NodeAgent.prototype.getApplicationIdentifier.call(NodeAgent);
         const sharedPidFile = path.join(process.env.WHATAP_HOME, `agent-${appIdentifier}.pid`);
 
@@ -843,12 +1016,11 @@ process.on('exit', () => {
 // graceful shutdown 처리 추가
 ['SIGTERM', 'SIGINT'].forEach((signal) => {
     process.on(signal, () => {
-        Logger.print("WHATAP-AGENT", `Received ${signal}, cleaning up...`, false);
+        Logger.print("WHATAP-050", `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._initialized) {
@@ -869,12 +1041,12 @@ NodeAgent.prototype.init = function(cb) {
     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);
+        return Logger.print("WHATAP-111", "Can not find application root directory", false);
     }
 
     // Initialize configuration with proper home directory
     if (!self.initConfig('WHATAP_HOME')) {
-        Logger.printError("WHATAP-CONFIG", "Failed to initialize configuration", null, true);
+        Logger.printError("WHATAP-051", "Failed to initialize configuration", null, false);
         return self;
     }
 
@@ -883,12 +1055,12 @@ NodeAgent.prototype.init = function(cb) {
     self._conf.init(this._userOpt, function(e) {
         if (e) {
             Logger.printError("WHATAP-112", "Configuration initialize error. " + e.message,
-                e, true);
+                e, false);
             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);
+            Logger.print("WHATAP-052", "ReqLog Init Start !!!!", false);
             RequestLog.initializer.process();
         }
 
@@ -963,11 +1135,12 @@ NodeAgent.prototype.loadObserves = function() {
         try {
             require(name);
         } catch (err) {
-            Logger.print("WHTAP-loadObserves", 'unable to load ' + name + ' module', false);
+            Logger.print("WHATAP-053", 'unable to load ' + name + ' module', false);
         }
     }
     new ProcessObserver(agent).inject(process, 'process');
     new GlobalObserver(agent).inject(global, 'global');
+    new CustomMethodObserver(agent).inject(null, 'custom-method');
 };
 
 NodeAgent.prototype.setServicePort = function (port) {
@@ -976,13 +1149,13 @@ NodeAgent.prototype.setServicePort = function (port) {
 
 NodeAgent.prototype.initUdp = function() {
     var self = this;
-    Logger.print('WHATAP-UDP', 'Initializing UDP connection...', false);
+    Logger.print('WHATAP-054', 'Initializing UDP connection...', false);
 
     // Configure the port before initializing UDP
     const configuredPort = self.configurePort();
     if (configuredPort) {
         self._conf['net_udp_port'] = configuredPort;
-        Logger.print('WHATAP-UDP', `Using configured port: ${configuredPort}`, false);
+        Logger.print('WHATAP-055', `Using configured port: ${configuredPort}`, false);
     }
 
     // Initialize the UDP session with updated config
@@ -991,27 +1164,11 @@ NodeAgent.prototype.initUdp = function() {
     // Initialize the async sender
     AsyncSender.startWhatapThread();
 
-    Logger.print('WHATAP-UDP', 'UDP connection initialized', false);
+    Logger.print('WHATAP-056', '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
+ * Initialize configuration with default values
  * @param {string} home - Environment variable name for home directory
  * @returns {boolean} - True if successful, false otherwise
  */
@@ -1026,9 +1183,7 @@ NodeAgent.prototype.initConfig = function(home) {
             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);
+            Logger.print("WHATAP-058", "WHATAP_HOME is empty", true);
         }
     }
 
@@ -1037,7 +1192,10 @@ NodeAgent.prototype.initConfig = function(home) {
     }
 
     process.env[home] = whatapHome;
-    const configFile = path.join(process.env[home], 'whatap.conf');
+
+    // Use WHATAP_CONF environment variable or default to 'whatap.conf'
+    const configFileName = process.env.WHATAP_CONF || 'whatap.conf';
+    const configFile = path.join(process.env[home], configFileName);
 
     if (!fs.existsSync(configFile)) {
         try {
@@ -1051,8 +1209,7 @@ NodeAgent.prototype.initConfig = function(home) {
                 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);
+            Logger.printError("WHATAP-059", "Permission error creating config file. Try to execute command: `sudo chmod -R 777 $WHATAP_HOME`", e, false);
             return false;
         }
     }