whatap-python 1.8.11__tar.gz → 1.8.12__tar.gz

{whatap_python-1.8.11 → whatap_python-1.8.12}/PKG-INFO

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

{whatap_python-1.8.11 → whatap_python-1.8.12}/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.12/whatap/build.py

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

{whatap_python-1.8.11 → whatap_python-1.8.12}/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 → whatap_python-1.8.12}/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 → whatap_python-1.8.12}/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.12/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 → whatap_python-1.8.12}/whatap/trace/mod/application/wsgi.py

@@ -77,6 +77,36 @@ def trace_handler(fn, start=False, preload=None):
 
     return handler
 
+def async_trace_handler(fn, start=False, preload=None):
+    def handler(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            if preload:
+                preload(*args, **kwargs)
+
+            ctx = TraceContextManager.getLocalContext()
+
+            if not start and not ctx:
+                return await fn(*args, **kwargs)
+
+            try:
+                callback = await func(*args, **kwargs)
+            except Exception as e:
+                if ctx and ctx.error_step == e:
+                    ctx.error_step = None
+                    raise e
+                raise
+            else:
+                if ctx and ctx.error_step:
+                    e = ctx.error_step
+                    ctx.error_step = None
+                    raise e
+                return callback
+
+        return wrapper
+
+    return handler
+
 
 def start_interceptor(ctx):
     if conf.dev:

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

@@ -1,6 +1,6 @@
 import inspect
 
-from whatap.trace.mod.application.wsgi import 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,
@@ -236,7 +236,7 @@ def _sync_wrapper(fn):
 
 
 def _async_wrapper(fn):
-    @trace_handler(fn)
+    @async_trace_handler(fn)
     async def wrapper(*args, **kwargs):
         if _is_called_by_pool():
             return await fn(*args, **kwargs)
@@ -278,7 +278,6 @@ def _get_conn_info(connection):
 
 
 def _pool_getconn_wrapper(original_getconn):
-    @trace_handler(original_getconn)
     def wrapper(self, *args, **kwargs):
         connection = original_getconn(self, *args, **kwargs)
         conn_info = _get_conn_info(connection)
@@ -291,16 +290,34 @@ def _pool_getconn_wrapper(original_getconn):
     return wrapper
 
 
-def _async_pool_getconn_wrapper(original_getconn):
-    @trace_handler(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
 
@@ -315,7 +332,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 → whatap_python-1.8.12}/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 → whatap_python-1.8.12}/whatap_python.egg-info/PKG-INFO

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

{whatap_python-1.8.11 → whatap_python-1.8.12}/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/whatap/build.py

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