whatap-python 1.8.11.post0__tar.gz → 1.8.13__tar.gz

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/PKG-INFO

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

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap/__init__.py

@@ -57,7 +57,7 @@ def preview_whatap_conf(option_name:str):
     현재 preview_whatap_conf 를 사용중인 옵션
     - ignore_whatap_stdout (False)
     - standalone_enabled (False)
-    - open_file_descriptor_enabled (False)
+    - counter_thread_enabled (False)
     """
     value = 'false'
     try:

whatap_python-1.8.13/whatap/build.py

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

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap/conf/configuration.py

@@ -215,6 +215,9 @@ Configuration = {
     "log_unhandled_exception": 'false',
     "threadstack_faulthandler": False,
     "max_send_queue_size": 1000,
-    "open_file_descriptor_enabled":False,
+    "open_file_descriptor_enabled": False,
     "open_file_descriptor_interval":60,
+    "counter_thread_enabled": False,
+    "llm_stat_enabled" : False,
+    "llm_stat_interval" : 5
 }

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap/counter/__init__.py

@@ -1,9 +1,9 @@
 from .counter_manager import CounterMgr  # CounterMgr 클래스 import
 from whatap import preview_whatap_conf
 
-open_file_descriptor_enabled = preview_whatap_conf("open_file_descriptor_enabled")
+counter_thread_enabled = preview_whatap_conf("counter_thread_enabled")
 
-if open_file_descriptor_enabled != 'false':
+if counter_thread_enabled != 'false':
     mgr = CounterMgr()
     mgr.setDaemon(True)
     mgr.start()

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap/counter/counter_manager.py

@@ -3,20 +3,27 @@ import time
 import logging
 from threading import Thread
 from .tasks.openfiledescriptor import OpenFileDescriptorTask
+from .tasks.llm_stat import LLMStatTask
 
 #현재 디렉토리 아래 tasks 가 있고 그안의 openfiledescriptor.py 파일에  OpenFileDescriptorTask 클래스를 import 하고싶어.
 
 class CounterMgr(Thread):
+    _instance = None
     def __init__(self):
         super(CounterMgr, self).__init__()  # Thread 초기화
         self.tasks = list()
         self.last_executed = {}  # 각 task의 마지막 실행 시간을 기록하기 위한 딕셔너리
-        
+        CounterMgr._instance = self
+
     def run(self):
-        # OpenFileDescriptorTask 인스턴스 생성 후 tasks에 추가
-        task = OpenFileDescriptorTask()
-        self.tasks.append(task)
-        self.last_executed[task.name()] = 0  # 각 task의 마지막 실행 시간을 초기화
+        ofd_task = OpenFileDescriptorTask()
+        self.tasks.append(ofd_task)
+        self.last_executed[ofd_task.name()] = 0  # 각 task의 마지막 실행 시간을 초기화
+
+        llm_task = LLMStatTask()
+        self.tasks.append(llm_task)
+        self.last_executed[llm_task.name()] = 0 # 각 task의 마지막 실행 시간을 초기화
+
         while True:
             current_time = time.time()  # 현재 시간을 초 단위로 가져옴
             time.sleep(1)  # 0.1초마다 확인 (부하 줄이기)

whatap_python-1.8.13/whatap/counter/tasks/llm_stat.py

@@ -0,0 +1,111 @@
+import whatap.net.async_sender as async_sender
+import whatap.io as whatapio
+from whatap.pack import tagCountPack
+from whatap.pack.tagCountPack import TagCountPack
+from whatap.util.hash_util import HashUtil
+from whatap import DateUtil
+
+import os
+import time
+from typing import List, Dict, Tuple
+from collections import defaultdict
+
+currentpid = os.getpid()
+
+
+class LLMStatTask:
+    def __init__(self):
+        self.llm_stats = {
+            'model_calls': defaultdict(int),
+            'model_prompt_tokens': defaultdict(int),
+            'model_completion_tokens': defaultdict(int)
+        }
+
+    def name(self):
+        return "LLMStatTask"
+
+    def interval(self):
+        from whatap.conf.configure import Configure as conf
+        return int(getattr(conf, 'llm_stat_interval', 5))
+
+    def process(self):
+        from whatap.conf.configure import Configure as conf
+        enabled = getattr(conf, 'llm_stat_enabled', False)
+        if not enabled:
+            return
+
+        stats = self.get_current_stats()
+
+        if not stats['model_calls']:
+            return
+
+        try:
+            p = TagCountPack()
+            p.time = DateUtil.now() // 1000 * 1000
+            p.Category = "llm_stat"
+            p.tags.putAuto("pid", currentpid)
+            p.tags.putAuto("!rectype", 2)
+
+            model_id_list = p.fields.newList("@id")
+            model_name_list = p.fields.newList("model_name")
+            call_count_list = p.fields.newList("call_count")
+            prompt_tokens_list = p.fields.newList("prompt_tokens")
+            completion_tokens_list = p.fields.newList("completion_tokens")
+            total_tokens_list = p.fields.newList("total_tokens")
+
+            for model_name, count in stats['model_calls'].items():
+                prompt_tokens = stats['model_prompt_tokens'][model_name]
+                completion_tokens = stats['model_completion_tokens'][model_name]
+                total_tokens = prompt_tokens + completion_tokens
+
+                model_id_list.addLong(HashUtil.hashFromString(model_name))
+                model_name_list.addString(model_name)
+                call_count_list.addLong(count)
+                prompt_tokens_list.addLong(prompt_tokens)
+                completion_tokens_list.addLong(completion_tokens)
+                total_tokens_list.addLong(total_tokens)
+
+
+            p.pcode = getattr(conf, 'PCODE', 0)
+            bout = whatapio.DataOutputX()
+            bout.writePack(p, None)
+            packbytes = bout.toByteArray()
+
+            async_sender.send_relaypack(packbytes)
+            self.reset_stats()
+
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+
+
+    def get_current_stats(self) -> Dict:
+        return {
+            'model_calls': dict(self.llm_stats['model_calls']),
+            'model_prompt_tokens': dict(self.llm_stats['model_prompt_tokens']),
+            'model_completion_tokens': dict(self.llm_stats['model_completion_tokens'])
+        }
+
+    def prepare_model_data(self, model_calls: Dict[str, int]) -> Tuple[List[str], List[int]]:
+        if not model_calls:
+            return [], []
+
+        models = list(model_calls.keys())
+        call_count = [model_calls[model] for model in models]
+
+        return models, call_count
+
+    def update_stats(self, prompt_tokens: int, completion_tokens: int,
+                     model_name: str):
+        self.llm_stats['model_calls'][model_name] += 1
+        self.llm_stats['model_prompt_tokens'][model_name] += prompt_tokens
+        self.llm_stats['model_completion_tokens'][model_name] += completion_tokens
+
+
+
+    def reset_stats(self):
+        self.llm_stats = {
+            'model_calls': defaultdict(int),
+            'model_prompt_tokens': defaultdict(int),
+            'model_completion_tokens': defaultdict(int)
+        }

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap/trace/mod/application/fastapi.py

@@ -443,6 +443,7 @@ def instrument_applications(module):
         async def trace(instance, scope, receive, send):
             if scope["type"] != "http":
                 await fn(instance, scope, receive, send)
+                return
             TraceContext()
             try:
                 await fn(instance, scope, receive, send)

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap/trace/mod/database/psycopg3.py

@@ -1,6 +1,6 @@
 import inspect
 
-from whatap.trace.mod.application.wsgi import trace_handler , async_trace_handler
+from whatap.trace.mod.application.wsgi import trace_handler, async_trace_handler
 from whatap.trace.mod.database.util import (
     interceptor_db_con, interceptor_db_execute, interceptor_db_close,
     async_interceptor_db_con, async_interceptor_db_execute, async_interceptor_db_close,
@@ -218,14 +218,17 @@ def _sync_wrapper(fn):
 
         db_info = {"type": "postgresql"}
 
-        if args and isinstance(args[0], str) and '=' in args[0]:
+        if args:
             conn_str = args[0]
-            parsed_kwargs = dict(
-                x.split('=') for x in conn_str.split()
-            )
-            kwargs.update(parsed_kwargs)
-
-        db_info.update(kwargs)
+            if isinstance(args[0], str) and '=' in args[0]:
+                parsed_kwargs = dict(
+                    x.split('=') for x in conn_str.split()
+                )
+                kwargs.update(parsed_kwargs)
+                db_info.update(kwargs)
+            else:
+                db_info.update({"db_con_stc": "completed"})
+                db_info.update({"db_str": args[0]})
 
         connection = interceptor_db_con(fn, db_info, *args, **kwargs)
         if hasattr(connection, '_is_wrapped'):
@@ -243,14 +246,18 @@ def _async_wrapper(fn):
 
         db_info = {"type": "postgresql"}
 
-        if args and isinstance(args[0], str) and '=' in args[0]:
+        if args:
             conn_str = args[0]
-            parsed_kwargs = dict(
-                x.split('=') for x in conn_str.split()
-            )
-            kwargs.update(parsed_kwargs)
+            if isinstance(args[0], str) and '=' in args[0]:
+                parsed_kwargs = dict(
+                    x.split('=') for x in conn_str.split()
+                )
+                kwargs.update(parsed_kwargs)
+                db_info.update(kwargs)
+            else:
+                db_info.update({"db_con_stc": "completed"})
+                db_info.update({"db_str": args[0]})
 
-        db_info.update(kwargs)
 
         connection = await async_interceptor_db_con(fn, db_info, *args, **kwargs)
         if hasattr(connection, '_is_wrapped'):
@@ -290,15 +297,34 @@ def _pool_getconn_wrapper(original_getconn):
     return wrapper
 
 
-def _async_pool_getconn_wrapper(original_getconn):
-    async def wrapper(self, *args, **kwargs):
-        connection = await original_getconn(self, *args, **kwargs)
+class AsyncConnectionProxy:
+    """AsyncConnectionPool.connection()이 반환하는 proxy 객체를 래핑"""
+
+    def __init__(self, proxy):
+        self._proxy = proxy
+        self._wrapped_connection = None
+
+    async def __aenter__(self):
+        connection = await self._proxy.__aenter__()
         conn_info = _get_conn_info(connection)
         db_info = {"type": "postgresql", "pool": True, **conn_info}
-
         await async_interceptor_pool_get(db_info)
 
-        return AsyncConnection(connection, db_info)
+        self._wrapped_connection = AsyncConnection(connection, db_info)
+        return self._wrapped_connection
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        if self._wrapped_connection:
+            await async_interceptor_pool_release()
+        return await self._proxy.__aexit__(exc_type, exc_val, exc_tb)
+
+
+def _async_pool_connection_wrapper(original_connection):
+    """AsyncConnectionPool.connection() 메서드를 래핑"""
+
+    def wrapper(self, *args, **kwargs):
+        proxy = original_connection(self, *args, **kwargs)
+        return AsyncConnectionProxy(proxy)
 
     return wrapper
 
@@ -313,7 +339,10 @@ def instrument_psycopg(module):
 
 def instrument_psycopg_pool(pool_module):
     if hasattr(pool_module, 'ConnectionPool'):
-        pool_module.ConnectionPool.getconn = _pool_getconn_wrapper(pool_module.ConnectionPool.getconn)
-    if hasattr(pool_module, 'AsyncConnectionPool'):
-        pool_module.AsyncConnectionPool.getconn = _async_pool_getconn_wrapper(pool_module.AsyncConnectionPool.getconn)
+        if hasattr(pool_module.ConnectionPool, 'getconn'):
+            pool_module.ConnectionPool.getconn = _pool_getconn_wrapper(pool_module.ConnectionPool.getconn)
 
+    if hasattr(pool_module, 'AsyncConnectionPool'):
+        if hasattr(pool_module.AsyncConnectionPool, 'connection'):
+            original_connection = pool_module.AsyncConnectionPool.connection
+            pool_module.AsyncConnectionPool.connection = _async_pool_connection_wrapper(original_connection)

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap/trace/mod/database/util.py

@@ -200,6 +200,10 @@ def interceptor_db_con(fn, db_info, *args, **kwargs):
         text += "/"
         text += db_info.get('user', '')
 
+    elif db_type == "postgresql":
+        if db_info.get('db_con_stc', '') == 'completed':
+            text = db_info.get('db_str', '')
+
     else:
         text = '{}://'.format(db_type)
         text += kwargs.get('user', '')
@@ -289,10 +293,17 @@ def interceptor_db_execute(fn, db_info, *args, **kwargs):
     except Exception as e:
         interceptor_step_error(e)
     finally:
-        datas = [ctx.lctx.get('dbc', ''), query, str(self.rowcount)]
+        try:
+            if hasattr(args[0], 'rowcount'):
+                count = args[0].rowcount
+            else:
+                count = -1
+        except AttributeError:
+            count = -1
+
+        datas = [ctx.lctx.get('dbc', ''), query, str(count)]
         ctx.elapsed = DateUtil.nowSystem() - start_time
         async_sender.send_packet(PacketTypeEnum.TX_SQL, ctx, datas)
-        count = self.rowcount
 
         if (count is not None) and (count > -1):
             desc = '{0}: {1}'.format('Fetch count', count)
@@ -351,6 +362,10 @@ async def async_interceptor_db_con(fn, db_info, *args, **kwargs):
 
     if db_type == "sqlite":
         text = "sqlite:"
+
+    elif db_type == "postgresql":
+        if db_info.get('db_con_stc', '') == 'completed':
+            text = db_info.get('db_str', '')
     else:
         text = '{}://'.format(db_type)
         text += kwargs.get('user', '')
@@ -445,10 +460,17 @@ async def async_interceptor_db_execute(fn, db_info, *args, **kwargs):
         interceptor_step_error(e)
         raise
     finally:
-        datas = [ctx.lctx.get('dbc', ''), query, str(self.rowcount)]
+        try:
+            if hasattr(args[0], 'rowcount'):
+                count = args[0].rowcount
+            else:
+                count = -1
+        except AttributeError:
+            count = -1
+
+        datas = [ctx.lctx.get('dbc', ''), query, str(count)]
         ctx.elapsed = DateUtil.nowSystem() - start_time
         async_sender.send_packet(PacketTypeEnum.TX_SQL, ctx, datas)
-        count = self.rowcount
 
         if (count is not None) and (count > -1):
             desc = '{0}: {1}'.format('Fetch count', count)

whatap_python-1.8.13/whatap/trace/mod/httpc/httpx.py

@@ -0,0 +1,36 @@
+from whatap.trace.mod.application.wsgi import transfer, trace_handler, \
+    interceptor_httpc_request
+
+
+def instrument_httpx(module):
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(*args, **kwargs):
+            if len(args) >= 2 and hasattr(args[1], 'headers') and hasattr(args[1], 'url'):
+                request = args[1]
+                request.headers = transfer(request.headers)
+                httpc_url = str(request.url)
+
+            # 2. stream call: send(request=request, ...)
+            elif len(args) == 1 and 'request' in kwargs:
+                request = kwargs['request']
+                if hasattr(request, 'headers') and hasattr(request, 'url'):
+                    request.headers = transfer(request.headers)
+                    httpc_url = str(request.url)
+                else:
+                    httpc_url = "invalid_request_object"
+
+            # 3. 예상치 못한 패턴
+            else:
+                httpc_url = "httpx_unknown_pattern"
+
+            return interceptor_httpc_request(fn, httpc_url, *args, **kwargs)
+
+        return trace
+
+    if hasattr(module, 'Client') and hasattr(module.Client, 'send'):
+        module.Client.send = wrapper(module.Client.send)
+
+
+    if hasattr(module, 'AsyncClient') and hasattr(module.AsyncClient, 'send'):
+        module.AsyncClient.send = wrapper(module.AsyncClient.send)

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap/trace/mod/llm/openai.py

@@ -3,8 +3,9 @@ import logging
 
 from openai import OpenAIError
 
-from whatap import DateUtil, conf
+from whatap import DateUtil
 from whatap.pack import logSinkPack
+from whatap.conf.configure import Configure as conf
 from whatap.trace.trace_context_manager import TraceContextManager
 from whatap.trace.mod.application.wsgi import trace_handler
 
@@ -37,6 +38,7 @@ def __send_llm_pack(metadata):
             'prompt_tokens': metadata.get('prompt_tokens'),
             'completion_tokens': metadata.get('completion_tokens'),
             'total_tokens': metadata.get('total_tokens'),
+            '@step_id' : ctx.mcallee
         }
 
         fields.update(llm_fields)
@@ -60,6 +62,28 @@ def __send_llm_pack(metadata):
         tags = {k: v for k, v in tags.items() if v is not None}
         fields = {k: v for k, v in fields.items() if v is not None}
 
+
+        # 4. LLM 통계 데이터 추가 (성공한 경우에만)
+        if metadata.get('success', False):
+            enabled = getattr(conf, 'llm_stat_enabled', False)
+            if not enabled:
+                return
+
+            try:
+                from whatap.counter.counter_manager import CounterMgr
+                prompt_tokens = metadata.get('prompt_tokens', 0) or 0
+                completion_tokens = metadata.get('completion_tokens', 0) or 0
+                model_name = metadata.get('model', 'unknown')
+
+                # 글로벌 카운터 매니저 인스턴스에서 LLM 태스크 찾아서 업데이트
+                if hasattr(CounterMgr, '_instance') and CounterMgr._instance:
+                    for task in CounterMgr._instance.tasks:
+                        if hasattr(task, 'update_stats') and task.name() == 'LLMStatTask':
+                            task.update_stats(prompt_tokens, completion_tokens, model_name)
+                            break
+            except Exception as e:
+                pass
+
         p = logSinkPack.getLogSinkPack(
             t=DateUtil.now(),
             category="LLMResponse",

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap_python.egg-info/PKG-INFO

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

{whatap_python-1.8.11.post0 → whatap_python-1.8.13}/whatap_python.egg-info/SOURCES.txt

@@ -21,6 +21,7 @@ whatap/control/__init__.py
 whatap/counter/__init__.py
 whatap/counter/counter_manager.py
 whatap/counter/tasks/__init__.py
+whatap/counter/tasks/llm_stat.py
 whatap/counter/tasks/openfiledescriptor.py
 whatap/io/__init__.py
 whatap/io/data_inputx.py

whatap_python-1.8.11.post0/whatap/build.py

@@ -1,4 +0,0 @@
-app = 'Python'
-name = 'whatap-python'
-version = '1.8.11.post0'
-release_date = '20250903'

whatap_python-1.8.11.post0/whatap/trace/mod/httpc/httpx.py

@@ -1,24 +0,0 @@
-from whatap.trace.mod.application.wsgi import transfer, trace_handler, \
-    interceptor_httpc_request
-
-
-def instrument_httpx(module):
-    def wrapper(fn):
-        @trace_handler(fn)
-        def trace(*args, **kwargs):
-            request = args[1]
-            request.headers = transfer(request.headers)
-
-            httpc_url = str(request.url)
-            callback = interceptor_httpc_request(fn, httpc_url, *args, **kwargs)
-
-            return callback
-
-        return trace
-
-    if hasattr(module, 'Client') and hasattr(module.Client, 'send'):
-        module.Client.send = wrapper(module.Client.send)
-
-
-    if hasattr(module, 'AsyncClient') and hasattr(module.AsyncClient, 'send'):
-        module.AsyncClient.send = wrapper(module.AsyncClient.send)