whatap 1.0.8 → 1.0.9

package/build.txt

@@ -1,4 +1,4 @@
 app = 'NodeJS'
 name = 'whatap_nodejs'
-version = 'dev1.0.5'
-build_date = '20250923'
+version = 'v1.0.9'
+build_date = '20251111'

package/lib/core/agent.js

@@ -121,7 +121,7 @@ NodeAgent.prototype.isNodejsAgentProcess = function(pid) {
                 if (fs.existsSync(cmdlineFile)) {
                     processCommand = fs.readFileSync(cmdlineFile, 'utf8');
                     // Log for debugging
-                    Logger.print("WHATAP-001", `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);
@@ -131,7 +131,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-001", `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;
@@ -144,7 +144,7 @@ NodeAgent.prototype.isNodejsAgentProcess = function(pid) {
                 const match = output.match(/"([^"]+)"/);
                 if (match && match[1]) {
                     processCommand = match[1];
-                    Logger.print("WHATAP-001", `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);
@@ -163,7 +163,7 @@ NodeAgent.prototype.isNodejsAgentProcess = function(pid) {
 
         // Check if the command contains the agent name
         const isAgentProcess = processCommand.indexOf(AGENT_NAME) >= 0;
-        Logger.print("WHATAP-002", `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-003", "Error in isNodejsAgentProcess", e, false);
@@ -209,7 +209,7 @@ NodeAgent.prototype.isGoAgentRunning = function(pid) {
             parseInt(pid) - 1
         ];
 
-        Logger.print("WHATAP-007", `Checking PIDs: ${pidsToCheck.join(', ')} (original: ${pid})`, false);
+        // Logger.print("WHATAP-007", `Checking PIDs: ${pidsToCheck.join(', ')} (original: ${pid})`, false);
 
         for (const pidToCheck of pidsToCheck) {
             try {
@@ -218,9 +218,9 @@ NodeAgent.prototype.isGoAgentRunning = function(pid) {
 
                 // whatap_nodejs 프로세스인지 확인
                 if (this.isNodejsAgentProcess(pidToCheck)) {
-                    Logger.print("WHATAP-008",
-                        `Found agent process at PID ${pidToCheck} (original PID in file: ${pid})`,
-                        false);
+                    // Logger.print("WHATAP-008",
+                    //     `Found agent process at PID ${pidToCheck} (original PID in file: ${pid})`,
+                    //     false);
                     return true;
                 }
             } catch (e) {
@@ -682,9 +682,9 @@ NodeAgent.prototype.getApplicationIdentifier = function() {
         .digest('hex')
         .substr(0, 8);
 
-    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);
+    // 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;
 };
@@ -718,6 +718,164 @@ NodeAgent.prototype.getApplicationName = function() {
     return path.basename(process.argv[1], '.js');
 };
 
+// Restart tracking variables
+NodeAgent.prototype._restartCount = 0;
+NodeAgent.prototype._lastRestartTime = 0;
+NodeAgent.prototype._maxRestarts = 5;
+NodeAgent.prototype._restartInterval = 10000; // 10초
+NodeAgent.prototype._healthCheckInterval = null;
+
+/**
+ * Start health check for whatap_nodejs process
+ * Periodically checks if the agent is running and restarts if needed
+ */
+NodeAgent.prototype.startHealthCheck = function() {
+    const self = this;
+    const whatapHome = process.env.WHATAP_HOME;
+
+    if (!whatapHome) {
+        Logger.print("WHATAP-206", "Cannot start health check: WHATAP_HOME not set", false);
+        return;
+    }
+
+    // Clear existing health check if any
+    if (self._healthCheckInterval) {
+        clearInterval(self._healthCheckInterval);
+    }
+
+    // PM2 cluster 모드에서는 첫 번째 인스턴스만 health check 수행
+    const isPM2Cluster = self.isPM2ClusterMode();
+    if (isPM2Cluster && process.env.pm_id !== '0') {
+        // Logger.print("WHATAP-207",
+        //     `PM2 cluster mode: Instance ${process.env.pm_id} will not run health check (only instance 0)`,
+        //     false);
+        return;
+    }
+
+    Logger.print("WHATAP-208", "Starting agent health check (interval: 30s)", false);
+
+    self._healthCheckInterval = setInterval(() => {
+        try {
+            const appIdentifier = self.getApplicationIdentifier();
+            const sharedPidFile = path.join(whatapHome, `agent-${appIdentifier}.pid`);
+
+            // PID 파일이 없으면 에이전트가 시작되지 않은 것
+            if (!fs.existsSync(sharedPidFile)) {
+                Logger.print("WHATAP-209", "Agent PID file not found, attempting to start...", false);
+                self.startGoAgent();
+                return;
+            }
+
+            // PID 읽기
+            const pid = fs.readFileSync(sharedPidFile, 'utf8').trim();
+            if (!pid) {
+                Logger.print("WHATAP-210", "Agent PID file is empty, attempting to start...", false);
+                self.startGoAgent();
+                return;
+            }
+
+            // 프로세스가 실행 중인지 확인
+            if (!self.isGoAgentRunning(pid)) {
+                Logger.printError("WHATAP-211",
+                    `Agent process (PID: ${pid}) is not running. Attempting restart...`,
+                    null, false);
+                self.restartGoAgent();
+            }
+        } catch (e) {
+            Logger.printError("WHATAP-212", "Error during health check", e, false);
+        }
+    }, 30000); // 30초마다 체크
+
+    // Node.js 프로세스 종료 시 health check도 정리
+    process.on('exit', () => {
+        if (self._healthCheckInterval) {
+            clearInterval(self._healthCheckInterval);
+        }
+    });
+};
+
+/**
+ * Stop health check
+ */
+NodeAgent.prototype.stopHealthCheck = function() {
+    if (this._healthCheckInterval) {
+        clearInterval(this._healthCheckInterval);
+        this._healthCheckInterval = null;
+        Logger.print("WHATAP-213", "Stopped agent health check", false);
+    }
+};
+
+/**
+ * Restart the Go agent
+ * @param {object} opts - Options for agent
+ * @returns {boolean} - True if restart attempted, false if blocked
+ */
+NodeAgent.prototype.restartGoAgent = function(opts = {}) {
+    const self = this;
+    const now = Date.now();
+    const timeSinceLastRestart = now - self._lastRestartTime;
+
+    // Reset restart count if enough time has passed (5 minutes)
+    if (timeSinceLastRestart > 300000) {
+        self._restartCount = 0;
+    }
+
+    // Check if we've exceeded max restarts
+    if (self._restartCount >= self._maxRestarts) {
+        Logger.printError("WHATAP-200",
+            `Max restart attempts (${self._maxRestarts}) reached. Agent will not restart automatically.`,
+            null, false);
+        return false;
+    }
+
+    // Check if restart interval has passed
+    if (timeSinceLastRestart < self._restartInterval) {
+        Logger.print("WHATAP-201",
+            `Restart interval not reached. Waiting ${(self._restartInterval - timeSinceLastRestart) / 1000}s`,
+            false);
+        return false;
+    }
+
+    self._restartCount++;
+    self._lastRestartTime = now;
+
+    Logger.print("WHATAP-202",
+        `Attempting to restart agent (attempt ${self._restartCount}/${self._maxRestarts})`,
+        false);
+
+    // Clean up lock and PID files before restart
+    const whatapHome = process.env.WHATAP_HOME;
+    if (whatapHome) {
+        const appIdentifier = self.getApplicationIdentifier();
+        const sharedLockFile = path.join(whatapHome, `agent-${appIdentifier}.lock`);
+        const sharedPidFile = path.join(whatapHome, `agent-${appIdentifier}.pid`);
+
+        try {
+            if (fs.existsSync(sharedLockFile)) fs.unlinkSync(sharedLockFile);
+            if (fs.existsSync(sharedPidFile)) fs.unlinkSync(sharedPidFile);
+            Logger.print("WHATAP-203", "Cleaned up lock and PID files", false);
+        } catch (e) {
+            Logger.printError("WHATAP-204", "Error cleaning up files before restart", e, false);
+        }
+    }
+
+    // Start the agent again
+    self.startGoAgent(opts);
+
+    // UDP 재초기화 (새 포트로 연결)
+    // whatap_nodejs가 daemon으로 전환되는 시간을 고려하여 지연 후 재초기화
+    setTimeout(() => {
+        try {
+            Logger.print("WHATAP-214", "Reinitializing UDP connection after agent restart...", false);
+            self.initUdp();
+        } catch (e) {
+            Logger.printError("WHATAP-215", "Error reinitializing UDP after restart", e, false);
+        }
+    }, 2000); // 2초 대기 (daemon 전환 시간 고려)
+
+    return true;
+};
+
 // startGoAgent with improved PID handling
 NodeAgent.prototype.startGoAgent = function(opts = {}) {
     const self = this;
@@ -830,23 +988,40 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
         const architecture = ARCH[process.arch] || process.arch;
         const sourcePath = path.join(__dirname, '..', '..', 'agent', platform, architecture, AGENT_NAME);
 
-        // 심볼릭 링크 생성
+        // sourcePath 존재 여부 확인
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Agent binary not found at ${sourcePath}. Platform: ${platform}, Architecture: ${architecture}`);
+        }
+
+        // 심볼릭 링크 또는 복사
         if (!fs.existsSync(agentPath)) {
             try {
                 fs.symlinkSync(sourcePath, agentPath);
                 Logger.print("WHATAP-036", `Created symbolic link for ${AGENT_NAME}`, false);
             } catch (e) {
                 if (e.code !== 'EEXIST') {
-                    if (platform === 'win32') {
-                        Logger.print("WHATAP-037", "Symlink failed, copying binary instead", false);
+                    // Symlink 실패 시 모든 플랫폼에서 복사 시도 (컨테이너 환경 대응)
+                    Logger.print("WHATAP-037", `Symlink failed (${e.code}), copying binary instead`, false);
+                    try {
                         fs.copyFileSync(sourcePath, agentPath);
-                    } else {
-                        throw e;
+                        // 실행 권한 부여
+                        fs.chmodSync(agentPath, 0o755);
+                        Logger.print("WHATAP-221", `Binary copied and made executable at ${agentPath}`, false);
+                    } catch (copyErr) {
+                        throw new Error(`Failed to copy agent binary: ${copyErr.message}`);
                     }
                 }
             }
         }
 
+        // agentPath 실행 권한 확인
+        try {
+            fs.accessSync(agentPath, fs.constants.X_OK);
+        } catch (e) {
+            Logger.print("WHATAP-222", `Agent binary not executable, adding execute permission`, false);
+            fs.chmodSync(agentPath, 0o755);
+        }
+
         // run 디렉토리 생성
         const sockfilePath = path.join(whatapHome, 'run');
         if (!fs.existsSync(sockfilePath)) {
@@ -900,80 +1075,77 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
                 cwd: whatapHome,
                 env: newEnv,
                 stdio: ['pipe', 'pipe', 'pipe'],
-                detached: true
+                detached: false
             }
         );
 
+        const MAX_BUFFER_SIZE = 50000; // 50KB - prevent memory leak
         let stdout = '';
         let stderr = '';
 
         agentProcess.stdout.on('data', (data) => {
             stdout += data.toString();
+            if (stdout.length > MAX_BUFFER_SIZE) {
+                stdout = ''; // Clear buffer when limit exceeded
+            }
         });
 
         agentProcess.stderr.on('data', (data) => {
             stderr += data.toString();
+            if (stderr.length > MAX_BUFFER_SIZE) {
+                stderr = ''; // Clear buffer when limit exceeded
+            }
         });
 
-        // PID 추적을 위한 추가 로직
+        // PID 추적 (detached: false이므로 agentProcess.pid가 실제 PID)
         agentProcess.on('spawn', () => {
-            Logger.print("WHATAP-039", `Agent process spawned with PID: ${agentProcess.pid}`, false);
+            const actualPid = agentProcess.pid;
+            Logger.print("WHATAP-039", `Agent process spawned with PID: ${actualPid}`, false);
 
-            // detached 프로세스에서 실제 PID가 다를 수 있으므로 잠시 대기 후 확인
-            setTimeout(() => {
+            // PID 파일에 기록
+            try {
+                fs.writeFileSync(sharedPidFile, actualPid.toString());
+                this.writeToFile(home, pidFileName, actualPid.toString());
+                Logger.print("WHATAP-040", `PID ${actualPid} written to PID files`, false);
+
+                // Lock 파일 해제 (spawn 완료 후 안전하게 삭제)
                 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-040",
-                                    `Found actual agent PID: ${foundPid} (spawn returned: ${agentProcess.pid})`,
-                                    false);
-
-                                // 실제 PID로 파일 업데이트
-                                fs.writeFileSync(sharedPidFile, foundPid);
-                                this.writeToFile(home, pidFileName, foundPid);
-                                return;
-                            }
-                        }
-                    }
+                    properLock.unlockSync(sharedLockFile);
+                    fs.unlinkSync(sharedLockFile);
+                    Logger.print("WHATAP-041", "Lock file released after spawn", false);
+                } catch (e) {}
+
+                // AGENT UP 메시지 (spawn 성공 후)
+                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);
+            } catch (e) {
+                Logger.printError("WHATAP-042", "Error writing PID to files", e, false);
+            }
+        });
 
-                    // 실제 PID를 찾지 못한 경우 spawn이 반환한 PID 사용
-                    Logger.print("WHATAP-041",
-                        `Using spawn PID: ${agentProcess.pid} (actual PID not found)`,
-                        false);
+        // spawn 에러 핸들러 (파일 없음, 권한 없음 등)
+        agentProcess.on('error', (err) => {
+            Logger.printError("WHATAP-216", `Failed to spawn agent process: ${err.message}`, err, false);
 
-                    fs.writeFileSync(sharedPidFile, agentProcess.pid.toString());
-                    this.writeToFile(home, pidFileName, agentProcess.pid.toString());
+            // 파일 정리
+            try { fs.unlinkSync(sharedLockFile); } catch (e) {}
+            try { fs.unlinkSync(sharedPidFile); } catch (e) {}
 
-                } catch (e) {
-                    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());
-                }
-            }, 1000); // 1초 대기
+            // PM2 cluster 모드에서는 instance 0만 재시작 시도
+            if (isPM2Cluster && process.env.pm_id !== '0') {
+                Logger.print("WHATAP-217",
+                    `Spawn failed but instance ${process.env.pm_id} will not restart (only instance 0)`,
+                    false);
+                return;
+            }
+
+            // 자동 재시작 시도
+            Logger.print("WHATAP-218", "Attempting to restart agent after spawn failure...", false);
+            setTimeout(() => {
+                self.restartGoAgent(opts);
+            }, 5000); // 5초 후 재시작 (spawn 실패는 더 긴 대기)
         });
 
         agentProcess.on('close', (code) => {
@@ -984,26 +1156,36 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
                 // 에이전트가 비정상 종료되면 파일 제거
                 try { fs.unlinkSync(sharedLockFile); } catch (e) {}
                 try { fs.unlinkSync(sharedPidFile); } catch (e) {}
+
+                // PM2 cluster 모드에서는 instance 0만 재시작 시도
+                if (isPM2Cluster && process.env.pm_id !== '0') {
+                    Logger.print("WHATAP-219",
+                        `Agent crashed but instance ${process.env.pm_id} will not restart (only instance 0)`,
+                        false);
+                    return;
+                }
+
+                // 자동 재시작 시도
+                Logger.print("WHATAP-220", "Attempting to restart agent after abnormal exit...", false);
+                setTimeout(() => {
+                    self.restartGoAgent(opts);
+                }, 2000); // 2초 후 재시작
             } else {
                 Logger.print("WHATAP-046", "Agent started successfully", false);
             }
         });
 
-        agentProcess.unref();
-
-        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) {}
+        // detached: false이므로 unref() 불필요 (부모 프로세스와 함께 종료됨)
+        // "AGENT UP!" 메시지는 spawn 이벤트 핸들러에서 출력됨 (line 1118-1122)
 
     } catch (e) {
         Logger.printError("WHATAP-048", "Error starting agent", e, false);
         // 에러 발생 시 파일 정리
-        try { fs.unlinkSync(sharedLockFile); } catch (e) {}
-        try { fs.unlinkSync(sharedPidFile); } catch (e) {}
+        try {
+            properLock.unlockSync(sharedLockFile);
+            fs.unlinkSync(sharedLockFile);
+        } catch (unlockErr) {}
+        try { fs.unlinkSync(sharedPidFile); } catch (pidErr) {}
     }
 };
 
@@ -1106,6 +1288,9 @@ NodeAgent.prototype.init = function(cb) {
         TraceContextManager.initialized = true;
 
         self.initUdp();
+
+        // Start health check to monitor agent process
+        self.startHealthCheck();
     });
 
     self.loadObserves();

package/lib/logger.js

@@ -161,7 +161,7 @@
      },
      openFile : function () {
          if(conf.log_file_enabled === false ) { return; }
-         var log_prefix = WHATAP_CONF+"-";
+         var log_prefix = WHATAP_CONF+"-hook-";
  
          var root = conf['app.root'];
          if(root==null || root ==undefined){

package/lib/udp/udp_session.js

@@ -16,6 +16,7 @@ const PackageCtrHelper = require('../../lib/control/packagectr-helper');
 const ActiveTransaction = require('../counter/task/activetransaction');
 const GCAction = require('../system/gc-action');
 const DataOuputX = require('../../lib/io/data-outputx');
+const Logger = require('../logger');
 
 class UdpSession {
     constructor() {
@@ -40,7 +41,7 @@ class UdpSession {
             try {
                 self.socket.close();
             } catch (e) {
-                console.error("Error closing UDP socket:", e);
+                Logger.printError("WHATAP-UDP-002", "Error closing UDP socket", e, false);
             }
         }
 
@@ -53,7 +54,7 @@ class UdpSession {
         if (conf.unix_socket_enabled === true && whatapHome) {
             // Unix socket not directly supported in Node.js dgram
             // We'll use the regular UDP socket with the configured server and port
-            console.log("Unix socket not supported in Node.js, using UDP instead");
+            Logger.print("WHATAP-UDP-003", "Unix socket not supported in Node.js, using UDP instead", false);
         }
 
         // Configure server info
@@ -72,7 +73,7 @@ class UdpSession {
 
         // Set up error handling
         self.socket.on('error', function (err) {
-            console.error("UDP socket error:", err);
+            Logger.printError("WHATAP-UDP-001", "UDP socket error", err, false);
         });
         self.socket.on('close', () => { self.isConnected = false; });
 
@@ -100,7 +101,7 @@ class UdpSession {
                 self.handle(paramId, request, extra);
             }
         } catch (e) {
-            console.error("Error handling UDP message:", e);
+            Logger.printError("WHATAP-UDP-004", "Error handling UDP message", e, false);
         }
     }
 
@@ -152,7 +153,7 @@ class UdpSession {
             }
             return;
         } catch (e) {
-            console.error("Error in handle method:", e);
+            Logger.printError("WHATAP-UDP-005", "Error in handle method", e, false);
         }
     }
 
@@ -217,7 +218,7 @@ class UdpSession {
 
                 if (diff < 0) {
                     data = ' ';
-                    console.log('message too long.');
+                    Logger.print("WHATAP-UDP-006", "UDP message too long, truncated", false);
                 }
 
                 dout.writeUTF(data);
@@ -241,7 +242,7 @@ class UdpSession {
                 }
             }
         } catch (e) {
-            console.error("Error sending packet:", e);
+            Logger.printError("WHATAP-UDP-007", "Error sending packet", e, false);
         }
     }
 
@@ -262,7 +263,7 @@ class UdpSession {
             // Send via UDP
             const cb = (err) => {
                 if (err) {
-                    console.error("Failed to send UDP packet:", err);
+                    Logger.printError("WHATAP-UDP-008", "Failed to send UDP packet", err, false);
                     // Consider reinitializing UDP connection on error
                     self.udp();
                 }
@@ -276,7 +277,7 @@ class UdpSession {
                 self.socket.send(sendbuf, 0, sendbuf.length, self.serverPort, self.serverHost, cb);
             }
         } catch (e) {
-            console.error("Error in send method:", e);
+            Logger.printError("WHATAP-UDP-009", "Error in send method", e, false);
         } finally {
             // Clear buffer array
             self.bufferArr = [];
@@ -327,7 +328,7 @@ class UdpSession {
                 self.threadLock = false;
             }
         } catch (e) {
-            console.error("Error sending relay pack:", e);
+            Logger.printError("WHATAP-UDP-010", "Error sending relay pack", e, false);
         }
     }
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whatap",
   "homepage": "http://www.whatap.io",
-  "version": "1.0.8",
-  "releaseDate": "20251106",
+  "version": "1.0.9",
+  "releaseDate": "20251111",
   "description": "Monitoring and Profiling Service",
   "main": "index.js",
   "scripts": {},

package/.claude/settings.local.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(chmod:*)",
-      "Bash(./fix_whatap_context.sh)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}