whatap-python 2.2.1__tar.gz → 2.2.2__tar.gz

{whatap_python-2.2.1 → whatap_python-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whatap-python
-Version: 2.2.1
+Version: 2.2.2
 Summary: Monitoring and Profiling Service
 Home-page: https://www.whatap.io
 Author: whatap

{whatap_python-2.2.1 → whatap_python-2.2.2}/whatap/__init__.py

@@ -562,9 +562,13 @@ def agent():
                 llm_accesskey = (preview_whatap_conf("llm_accesskey")
                                  or os.environ.get("llm_accesskey"))
                 if llm_accesskey:
-                    t = threading.Thread(target=go, kwargs={'llm': True})
-                    t.setDaemon(True)
-                    t.start()
+                    if sys.platform.startswith('linux'):
+                        # APM 과 같은 이유로 소유 기록까지 호출 스레드에서 끝낸다.
+                        go(llm=True)
+                    else:
+                        t = threading.Thread(target=go, kwargs={'llm': True})
+                        t.setDaemon(True)
+                        t.start()
                 else:
                     whatap_print("WHATAP: llm_enabled=true 이나 llm_accesskey 가 "
                                  "없어 LLM 에이전트 기동을 건너뜁니다")
@@ -636,24 +640,31 @@ def llm_agent_path():
 
 
 
-def _native_agent_spec(opts):
-    from whatap.util.native_process import AgentSpec
-    source = os.path.join(os.path.dirname(__file__), 'agent', 'linux',
-                          ARCH[platform.machine()], AGENT_NAME)
+def _native_agent_spec(opts, llm_executable=None):
+    from whatap.util.native_process import APM, LLM, AgentSpec
+    if llm_executable:
+        # LLM 은 llm_agent_path() 의 전용 바이너리를 제자리에서 실행한다(@see _start_go).
+        source, mode = llm_executable, LLM
+    else:
+        source = os.path.join(os.path.dirname(__file__), 'agent', 'linux',
+                              ARCH[platform.machine()], AGENT_NAME)
+        mode = APM
     env = os.environ.copy()
     env.update(opts)
-    return AgentSpec(os.environ['WHATAP_HOME'], source, env)
+    return AgentSpec(os.environ['WHATAP_HOME'], source, env, mode=mode)
 
 
-def _native_agent_log_path():
-    return os.path.join(os.environ.get('WHATAP_HOME', '.'), 'logs', AGENT_NAME + '.log')
+def _native_agent_log_path(llm=False):
+    # LLM 은 별개 프로세스라 기동 실패 원인이 APM 로그와 섞이지 않게 나눈다.
+    name = AGENT_NAME + ('.llm.log' if llm else '.log')
+    return os.path.join(os.environ.get('WHATAP_HOME', '.'), 'logs', name)
 
 
-def _open_native_agent_log():
+def _open_native_agent_log(llm=False):
     # managed 경로는 PIPE 를 읽지 않으므로 네이티브 stdout/stderr 를 파일로 남겨
     # 기동 직후 실패 원인을 추적할 수 있게 한다.
     try:
-        log_path = _native_agent_log_path()
+        log_path = _native_agent_log_path(llm)
         os.makedirs(os.path.dirname(log_path), exist_ok=True)
         return open(log_path, 'ab')
     except Exception as e:
@@ -662,29 +673,40 @@ def _open_native_agent_log():
 
 
 def go(batch=False, opts={}, llm=False):
-    if sys.platform.startswith('linux') and not batch and not llm:
+    if sys.platform.startswith('linux') and not batch:
         from whatap.util.native_process import FAILED, ensure_agent_running
+        label = 'LLM' if llm else 'APM'
+        log_prefix = 'WHATAP_LLM_AGENT' if llm else 'WHATAP_AGENT'
+        llm_executable = None
+        if llm:
+            # 바이너리가 없으면 락·/proc 탐색 전에 기존처럼 건너뛴다.
+            llm_executable, reason = llm_agent_path()
+            if llm_executable is None:
+                whatap_error_log(
+                    'WHATAP: skipping LLM agent start — {0}'.format(reason),
+                    log_id='WHATAP_LLM_AGENT_UNAVAILABLE')
+                return
 
         def on_child_exit(pid, exit_code):
             whatap_error_log(
-                'WHATAP: native APM exited (PID: {}, exit code: {}, log: {})'.format(
-                    pid, exit_code, _native_agent_log_path()),
-                log_id='WHATAP_AGENT_EXITED')
+                'WHATAP: native {} exited (PID: {}, exit code: {}, log: {})'.format(
+                    label, pid, exit_code, _native_agent_log_path(llm)),
+                log_id=log_prefix + '_EXITED')
 
         try:
-            spec = _native_agent_spec(opts)
+            spec = _native_agent_spec(opts, llm_executable)
             result = ensure_agent_running(
                 spec, lambda: _start_go(batch, opts, llm, managed=True),
                 on_child_exit=on_child_exit)
             if result.status == FAILED:
-                whatap_error_log('WHATAP: native APM startup failed',
-                                 log_id='WHATAP_AGENT_START_FAILED')
+                whatap_error_log('WHATAP: native {} startup failed'.format(label),
+                                 log_id=log_prefix + '_START_FAILED')
             else:
-                whatap_print('WHATAP: native APM {} (PID: {})'.format(
-                    result.status, result.pid))
+                whatap_print('WHATAP: native {} {} (PID: {})'.format(
+                    label, result.status, result.pid))
         except Exception as e:
-            whatap_error_log('WHATAP: native APM startup failed: {}'.format(e),
-                             log_id='WHATAP_AGENT_START_FAILED')
+            whatap_error_log('WHATAP: native {} startup failed: {}'.format(label, e),
+                             log_id=log_prefix + '_START_FAILED')
         return
     return _start_go(batch, opts, llm)
 
@@ -895,7 +917,7 @@ def _start_go(batch=False, opts={}, llm=False, managed=False):
                                            creationflags=DETACHED_PROCESS,
                                            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         elif managed:
-            go_out = _open_native_agent_log()
+            go_out = _open_native_agent_log(llm)
             try:
                 process = subprocess.Popen(cmd_args,
                                            cwd=home_path, env=newenv,
@@ -1250,6 +1272,26 @@ def _config_port():
 
 
 def configLlmPort():
+    if sys.platform.startswith('linux') and preview_whatap_conf('llm_enabled') == 'true':
+        # 바이너리가 없으면 go(llm=True) 도 건너뛰므로 지킬 LLM 에이전트가 없다.
+        llm_executable = llm_agent_path()[0]
+        if llm_executable:
+            from whatap.util.native_process import LLM, acquire_start_lock, configured_channel, find_existing_agent
+            try:
+                spec = _native_agent_spec({}, llm_executable)
+                with acquire_start_lock(spec):
+                    if find_existing_agent(spec):
+                        # configPort() 와 같은 계약: 살아 있는 LLM 에이전트의 채널을 다시 쓰지 않는다.
+                        return configured_channel(spec.home, spec.environment,
+                                                  include_unix=False, mode=LLM)[1]
+                    return _config_llm_port()
+            except Exception as e:
+                # 락 타임아웃/다중 인스턴스 등은 CLI 를 죽이지 말고 기존 포트 할당으로 폴백
+                whatap_print('WHATAP: live LLM agent check skipped, falling back to port file: %s' % e)
+    return _config_llm_port()
+
+
+def _config_llm_port():
     # force_llm_net_udp_port가 설정된 경우 lock 파일 무시하고 해당 포트 강제 사용
     force_port_str = preview_whatap_conf("force_llm_net_udp_port")
     if force_port_str and force_port_str not in ('false', 'False'):

whatap_python-2.2.2/whatap/build.py

@@ -0,0 +1,4 @@
+app = 'Python'
+name = 'whatap-python'
+version = '2.2.2'
+release_date = '20261019'

{whatap_python-2.2.1 → whatap_python-2.2.2}/whatap/util/native_process.py

@@ -1,4 +1,4 @@
-"""Linux APM native process ownership (not instrumentation configuration)."""
+"""Linux APM/LLM native process ownership (not instrumentation configuration)."""
 import os
 import errno
 import fcntl
@@ -23,12 +23,22 @@ DISCOVERY_TIMEOUT_SECONDS = 1.0
 LOCK_TIMEOUT_SECONDS = 1.0
 LOCK_RETRY_SECONDS = 0.01
 DEFAULT_UDP_PORT = 6600
+DEFAULT_LLM_UDP_PORT = 6700
 CONFIG_MAX_BYTES = 1024 * 1024
 RECORD_MAX_BYTES = 8192
 CHILD_STOP_TIMEOUT_SECONDS = 2.0
 STARTUP_GRACE_SECONDS = 0.5
 STARTUP_POLL_SECONDS = 0.05
 _TRUE_VALUES = ('1', 't', 'T', 'true', 'TRUE', 'True')
+APM = 'apm'
+LLM = 'llm'
+# The same native binary name serves both modes. --llm switches only the UDP
+# listener key (Go Config.go: LLMMode reads llm_net_udp_port); unix_socket keys
+# are shared. Values: native key, its uppercase ENV alias, native default.
+_UDP_PORT_KEYS = {APM: ('net_udp_port', 'WHATAP_NET_UDP_PORT', DEFAULT_UDP_PORT),
+                  LLM: ('llm_net_udp_port', 'WHATAP_LLM_NET_UDP_PORT', DEFAULT_LLM_UDP_PORT)}
+# Exactly the arguments the native pre-scan accepts as LLM mode.
+_LLM_FLAGS = (b'--llm', b'-llm')
 _watchers = set()
 _watchers_lock = threading.Lock()
 _start_lock_fds = set()
@@ -106,14 +116,15 @@ def watch_owned_child(pid, process=None, on_exit=None):
         raise
 
 
-def configured_channel(home, env, include_unix=True):
+def configured_channel(home, env, include_unix=True, mode=APM):
     """Read only native transport keys, including native file/ENV precedence.
 
     whatap.port is an object identity input, NOT the UDP listener port.
     """
-    aliases = {'net_udp_port': 'WHATAP_NET_UDP_PORT',
+    port_key, port_alias, default_port = _UDP_PORT_KEYS[mode]
+    aliases = {port_key: port_alias,
                'use_env_first': 'WHATAP_USE_ENV_FIRST'}
-    keys = ('net_udp_port', 'use_env_first', 'unix_socket_enabled', 'unix_socket')
+    keys = (port_key, 'use_env_first', 'unix_socket_enabled', 'unix_socket')
     config_home = env.get('WHATAP_CONFIG_HOME') or home
     config_name = env.get('WHATAP_CONFIG') or 'whatap.conf'
     # Preserve Go path.Join semantics before resolving against native cwd.
@@ -149,11 +160,12 @@ def configured_channel(home, env, include_unix=True):
         return value or default
 
     if include_unix and get('unix_socket_enabled', 'false') in _TRUE_VALUES:
-        # Go path.Join joins even a leading slash in its second argument.
+        # Go path.Join joins even a leading slash in its second argument. LLM
+        # mode binds this same path, so an APM-owned socket makes it occupied.
         path = os.path.normpath(home + '/' + get('unix_socket', 'whatap.sock'))
         return ('unix', path)
     try:
-        value = get('net_udp_port', str(DEFAULT_UDP_PORT))
+        value = get(port_key, str(default_port))
         # Native strconv.ParseInt(value, 10, 32) rejects Python-only syntax.
         if re.fullmatch(r'[+-]?[0-9]+', value) is None:
             raise ValueError('invalid native decimal')
@@ -161,9 +173,9 @@ def configured_channel(home, env, include_unix=True):
         if not -2147483648 <= port <= 2147483647:
             raise ValueError('native decimal exceeds int32')
     except ValueError:
-        port = DEFAULT_UDP_PORT
+        port = default_port
     if not 0 <= port <= 65535:
-        raise ValueError('native APM UDP port is out of range')
+        raise ValueError('native {} UDP port is out of range'.format(mode.upper()))
     return ('udp', port)
 
 
@@ -207,22 +219,34 @@ def owns_socket(pid, inodes):
 
 
 class AgentSpec(object):
-    def __init__(self, home, executable, env=None):
+    def __init__(self, home, executable, env=None, mode=APM):
+        if mode not in _UDP_PORT_KEYS:
+            raise ValueError('unknown native agent mode: {!r}'.format(mode))
+        self.mode = mode
+        self.label = mode.upper()
         self.home = os.path.realpath(home)
         self.executable = os.path.realpath(executable)
         environment = os.environ if env is None else env
         # Retain only transport/config-location keys, never credentials.
         self.environment = {key: environment[key] for key in (
-            'net_udp_port', 'WHATAP_NET_UDP_PORT', 'use_env_first',
+            'net_udp_port', 'WHATAP_NET_UDP_PORT', 'llm_net_udp_port',
+            'WHATAP_LLM_NET_UDP_PORT', 'use_env_first',
             'WHATAP_USE_ENV_FIRST', 'unix_socket_enabled', 'unix_socket',
             'WHATAP_CONFIG_HOME', 'WHATAP_CONFIG') if key in environment}
         self.channel = None  # Read under the startup lock, not before waiting.
-        self.pid_file = Path(self.home) / 'whatap_python.pid'
         namespaces = '{}-{}'.format(os.stat('/proc/self/ns/pid').st_ino,
                                    os.stat('/proc/self/ns/net').st_ino)
         self.namespaces = namespaces
-        self.lock_file = Path(self.home) / ('whatap_python.' + namespaces + '.lock')
-        self.record_file = Path(self.home) / ('whatap_python.' + namespaces + '.runtime.json')
+        # APM file names predate LLM support. LLM keeps its legacy PID file name
+        # and never shares a lock/record with APM: the modes start independently.
+        if mode == APM:
+            self.pid_file = Path(self.home) / 'whatap_python.pid'
+            prefix = 'whatap_python.'
+        else:
+            self.pid_file = Path(self.home) / 'whatap_python.pid.llm'
+            prefix = 'whatap_python.llm.'
+        self.lock_file = Path(self.home) / (prefix + namespaces + '.lock')
+        self.record_file = Path(self.home) / (prefix + namespaces + '.runtime.json')
 
 
 def _process_stat(pid):
@@ -237,7 +261,7 @@ def _read_record(spec):
         with spec.record_file.open() as stream:
             content = stream.read(RECORD_MAX_BYTES + 1)
         if len(content) > RECORD_MAX_BYTES:
-            raise RuntimeError('native APM ownership record is too large')
+            raise RuntimeError('native {} ownership record is too large'.format(spec.label))
         value = json.loads(content)
         return value if isinstance(value, dict) else {}
     except (FileNotFoundError, ValueError):
@@ -260,7 +284,7 @@ def _atomic_write(path, content):
 def write_runtime_record(spec, pid):
     info = _process_stat(pid)
     if info['state'] in ('Z', 'X'):
-        raise RuntimeError('native APM exited during startup')
+        raise RuntimeError('native {} exited during startup'.format(spec.label))
     record = {'pid': pid, 'start_time': info['start_time'],
               'channel': list(spec.channel), 'namespaces': spec.namespaces}
     if _read_record(spec) != record:
@@ -290,7 +314,7 @@ def acquire_start_lock(spec):
     try:
         info = os.fstat(fd)
         if not stat.S_ISREG(info.st_mode) or info.st_nlink != 1:
-            raise RuntimeError('unsafe native APM lock file')
+            raise RuntimeError('unsafe native {} lock file'.format(spec.label))
         deadline = time.monotonic() + LOCK_TIMEOUT_SECONDS
         while True:
             try:
@@ -300,7 +324,7 @@ def acquire_start_lock(spec):
                 if error.errno not in (errno.EAGAIN, errno.EACCES):
                     raise
                 if time.monotonic() >= deadline:
-                    raise TimeoutError('native APM startup lock is busy')
+                    raise TimeoutError('native {} startup lock is busy'.format(spec.label))
                 time.sleep(LOCK_RETRY_SECONDS)
         yield
     finally:
@@ -324,7 +348,8 @@ def _matching_process(pid, spec, record):
         if os.path.realpath(os.readlink(str(root / 'cwd'))) != spec.home:
             return False
         args = (root / 'cmdline').read_bytes().split(b'\0')
-        if b'--llm' in args:
+        if any(flag in args for flag in _LLM_FLAGS) != (spec.mode == LLM):
+            # APM and LLM share the name and home; never adopt the other mode.
             return False
         namespaces = '{}-{}'.format(os.stat(str(root / 'ns/pid')).st_ino,
                                    os.stat(str(root / 'ns/net')).st_ino)
@@ -332,17 +357,20 @@ def _matching_process(pid, spec, record):
             return False
         process_exe = str(root / 'exe')
         same_binary = os.path.samefile(process_exe, spec.executable)
-        if not same_binary and os.path.realpath(os.readlink(process_exe)) == os.path.join(spec.home, 'whatap_python'):
+        if (not same_binary and spec.mode == APM and
+                os.path.realpath(os.readlink(process_exe)) == os.path.join(spec.home, 'whatap_python')):
             # _start_go copies when the filesystem does not support symlinks.
             # Path/name alone is insufficient: compare the actual executable.
             same_binary = filecmp.cmp(process_exe, spec.executable, shallow=False)
         if not same_binary:
             if (root / 'comm').read_text().strip() == 'whatap_python':
-                raise RuntimeError('different native APM executable is already running in this home')
+                raise RuntimeError('different native {} executable is already running in this home'.format(
+                    spec.label))
             return False
         if record.get('pid') == pid and record.get('start_time') == info['start_time']:
             if record.get('channel') != list(spec.channel):
-                raise RuntimeError('running native APM channel differs from current configuration')
+                raise RuntimeError('running native {} channel differs from current configuration'.format(
+                    spec.label))
         return True
     except (FileNotFoundError, ProcessLookupError):
         return False
@@ -350,7 +378,7 @@ def _matching_process(pid, spec, record):
 
 def find_existing_agent(spec):
     """Caller holds acquire_start_lock, including during port-file allocation."""
-    spec.channel = configured_channel(spec.home, spec.environment)
+    spec.channel = configured_channel(spec.home, spec.environment, mode=spec.mode)
     record = _read_record(spec)
     recorded_pid = record.get('pid')
     if isinstance(recorded_pid, int) and recorded_pid > 0:
@@ -367,7 +395,7 @@ def find_existing_agent(spec):
     with os.scandir('/proc') as entries:
         for entry in entries:
             if time.monotonic() > deadline:
-                raise RuntimeError('native APM process discovery timed out')
+                raise RuntimeError('native {} process discovery timed out'.format(spec.label))
             if not entry.name.isdigit():
                 continue
             try:
@@ -380,7 +408,7 @@ def find_existing_agent(spec):
             except (FileNotFoundError, ProcessLookupError):
                 continue
     if len(matches) > 1:
-        raise RuntimeError('multiple native APM instances already exist')
+        raise RuntimeError('multiple native {} instances already exist'.format(spec.label))
     return matches[0] if matches else None
 
 
@@ -419,7 +447,7 @@ def _ensure_locked(spec, spawn, on_child_exit=None):
     pid = find_existing_agent(spec)
     occupied = channel_socket_inodes(spec.channel)
     if occupied and (not pid or not owns_socket(pid, occupied)):
-        raise RuntimeError('native APM channel is occupied by another process')
+        raise RuntimeError('native {} channel is occupied by another process'.format(spec.label))
     if pid:
         previous = _read_record(spec)
         known = (previous.get('pid') == pid and
@@ -439,8 +467,8 @@ def _ensure_locked(spec, spawn, on_child_exit=None):
         return StartResult(FAILED, None)
     exit_code = _early_exit_code(process)
     if exit_code is not None:
-        raise RuntimeError('native APM exited immediately (PID {}, exit code {})'.format(
-            process.pid, exit_code))
+        raise RuntimeError('native {} exited immediately (PID {}, exit code {})'.format(
+            spec.label, process.pid, exit_code))
     try:
         record = write_runtime_record(spec, process.pid)
         watch_owned_child(process.pid, process,

{whatap_python-2.2.1 → whatap_python-2.2.2}/whatap_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: whatap-python
-Version: 2.2.1
+Version: 2.2.2
 Summary: Monitoring and Profiling Service
 Home-page: https://www.whatap.io
 Author: whatap

whatap_python-2.2.1/whatap/build.py

@@ -1,4 +0,0 @@
-app = 'Python'
-name = 'whatap-python'
-version = '2.2.1'
-release_date = '20260929'