whatap-python 1.8.9.post0__tar.gz → 1.8.14__tar.gz

{whatap_python-1.8.9.post0 → whatap_python-1.8.14}/PKG-INFO

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

{whatap_python-1.8.9.post0 → whatap_python-1.8.14}/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.14/whatap/build.py

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

{whatap_python-1.8.9.post0 → whatap_python-1.8.14}/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.9.post0 → whatap_python-1.8.14}/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.9.post0 → whatap_python-1.8.14}/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.14/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.9.post0 → whatap_python-1.8.14}/whatap/net/udp_session.py

@@ -212,9 +212,6 @@ class UdpSession(object):
                 datas.append(data)
 
             cls.send_packet(PacketTypeEnum.ACTIVE_STACK, None, datas)
-            stats = TraceContextManager.getActiveStats()
-            datas = [','.join([str(x) for x in stats])]
-            cls.send_packet(PacketTypeEnum.ACTIVE_STATS, None, datas)
         else:
             # param pack
             # format: "[packetType], [ctx], [datas: xxxx xxxx xxxx]"

{whatap_python-1.8.9.post0 → whatap_python-1.8.14}/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.9.post0 → whatap_python-1.8.14}/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:
@@ -263,6 +293,7 @@ def interceptor_error(status_code, errors, ctx=None):
 
 
 def interceptor_step_error(e, ctx=None):
+    from whatap.trace.mod.database.util import extract_db_error_message
     if not ctx:
         ctx = TraceContextManager.getLocalContext()
     if not ctx:
@@ -301,25 +332,6 @@ def interceptor_step_error(e, ctx=None):
         async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
 
 
-def extract_db_error_message(e):
-    try:
-        # PostgreSQL (psycopg2)
-        if hasattr(e, 'pgcode') and hasattr(e, 'pgerror'):
-            return str(e.pgerror)
-
-        # MySQL (PyMySQL, mysql-connector-python)
-        if hasattr(e, 'args') and len(e.args) > 1 and isinstance(e.args[1], str):
-            return e.args[1]
-
-        # 기본 에러 메시지
-        if hasattr(e, 'args') and len(e.args) > 0:
-            if isinstance(e.args[0], str):
-                return e.args[0]
-            return str(e.args[0])
-
-        return str(e)
-    except:
-        return "Unknown database error"
 
 
 def interceptor_httpc_request(fn, httpc_url, *args, **kwargs):
@@ -385,213 +397,6 @@ def interceptor_sock_connect(fn, *args, **kwargs):
         ctx.socket_connecting = False
 
 
-def interceptor_db_con(fn, db_info, *args, **kwargs):
-    ctx = TraceContextManager.getLocalContext()
-    if not ctx:
-        return fn(*args, **kwargs)
-
-    start_time = DateUtil.nowSystem()
-    ctx.start_time = start_time
-
-    ctx.db_opening = True
-    try:
-        callback = fn(*args, **kwargs)
-    finally:
-        ctx.db_opening = False
-
-    if not kwargs:
-        kwargs = dict(
-            x.split('=') for x in re.sub(r'\s*=\s*', '=', args[0]).split())
-
-    db_type = db_info.get('type')
-
-    if db_type == "sqlite":
-        text = "sqlite:"
-    else:
-        text = '{}://'.format(db_type)
-        text += kwargs.get('user', '')
-        text += "@"
-        text += kwargs.get('host', kwargs.get('dsn', ''))
-        text += '/'
-
-    text += kwargs.get('database', kwargs.get('db', kwargs.get('dbname', '')))
-    ctx.active_dbc = text
-    ctx.lctx['dbc'] = text
-
-    ctx.active_dbc = 0
-
-    datas = [text]
-    ctx.elapsed = DateUtil.nowSystem() - start_time
-    async_sender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, datas)
-
-    return callback
-
-
-def addQuoteDict(arg_dict):
-    quoted_dict = dict()
-
-    for k, v in arg_dict.items():
-        if isinstance(v, str):
-            quoted_dict[k] = "'" + v.replace("'", "\\'") + "'"
-        else:
-            quoted_dict[k] = v
-
-    return quoted_dict
-
-
-def addQuoteList(arg_list):
-    quoted_list = list()
-
-    for v in arg_list:
-        if isinstance(v, str):
-            quoted_list.append("'" + v.replace("'", "\\'") + "'")
-        else:
-            quoted_list.append("'" + str(v) + "'")
-
-    return tuple(quoted_list)
-
-def neo4jQuery(query,paremeter):
-    neo4j_query = query
-
-    for key, value in paremeter.items():
-        placeholder = f"${key}"
-        replacement = f"'{str(value)}'"
-        neo4j_query = neo4j_query.replace(placeholder, replacement)
-
-    return neo4j_query
-
-def sqliteQuery(query, paremeter):
-    sqlite_query = query
-
-    def quote(v):
-        if v is None: return "NULL"
-        if isinstance(v, (bytes, bytearray)): return "X'" + v.hex() + "'"
-        return "'" + str(v).replace("'", "''") + "'"
-
-    # 이름 기반: :name / @name / $name (단일 세트)
-    if isinstance(paremeter, dict):
-        for pfx in (':', '@', '$'):
-            for k, v in paremeter.items():
-                sqlite_query = sqlite_query.replace(f"{pfx}{k}", quote(v))
-        return sqlite_query
-
-    # 포지셔널 + executemany 분기
-    if isinstance(paremeter, (list, tuple)):
-        # ── executemany: [tuple|dict, ...] ──
-        if isinstance(paremeter, list) and paremeter and isinstance(paremeter[0], (tuple, dict)):
-            stmts = []
-            for params in paremeter:
-                sqlite_query = query
-                if isinstance(params, dict):
-                    for pfx in (':', '@', '$'):
-                        for k, v in params.items():
-                            sqlite_query = sqlite_query.replace(f"{pfx}{k}", quote(v))
-                else:  # tuple
-                    for i, v in enumerate(params, 1):
-                        sqlite_query = sqlite_query.replace(f"?{i}", quote(v))
-                    for v in params:
-                        sqlite_query = sqlite_query.replace('?', quote(v), 1)
-                stmts.append(sqlite_query)
-            return ";\n".join(stmts)
-
-        # ── 단일 포지셔널 세트 (tuple 또는 스칼라 list) ──
-        seq = paremeter if isinstance(paremeter, tuple) else tuple(paremeter)
-        for i, v in enumerate(seq, 1):
-            sqlite_query = sqlite_query.replace(f"?{i}", quote(v))
-        for v in seq:
-            sqlite_query = sqlite_query.replace('?', quote(v), 1)
-        return sqlite_query
-
-    return sqlite_query
-
-def interceptor_db_execute(fn, db_info, *args, **kwargs):
-    ctx = TraceContextManager.getLocalContext()
-    # sendDebugProfile(ctx, 'interceptor_db_execute step -1')
-    self = args[0]
-    db_type = db_info.get('type')
-    query = None
-
-    if db_type == "neo4j":
-        try:
-            query = neo4jQuery(args[1], kwargs)
-        except Exception as e:
-            pass
-
-    elif db_type == "sqlite" and len(args) > 2:
-        try:
-            query = sqliteQuery(args[1],args[2])
-        except Exception as e:
-            pass
-
-    else:
-        if len(args) > 2 and type(args[2]) == dict and args[2]:
-            try:
-                query = args[1] % addQuoteDict(args[2])
-            except Exception as e:
-                pass
-        if len(args) > 2 and type(args[2]) in (list, tuple) and args[2]:
-            try:
-                query = args[1] % addQuoteList(args[2])
-            except Exception as e:
-                pass
-    try:
-        if not query:
-            query = args[1].decode()
-    except Exception as e:
-        query = args[1]
-
-    if not query:
-        return fn(*args, **kwargs)
-
-    start_time = DateUtil.nowSystem()
-    ctx.start_time = start_time
-    ctx.active_sqlhash = query
-    try:
-        callback = fn(*args, **kwargs)
-        return callback
-    except Exception as e:
-        interceptor_step_error(e)
-    finally:
-        datas = [ctx.lctx.get('dbc', ''), query, str(self.rowcount)]
-        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)
-            datas = [' ', ' ', desc]
-            ctx.elapsed = 0
-            async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
-
-        ctx.active_sqlhash = 0
-
-
-def interceptor_db_close(fn, *args, **kwargs):
-    ctx = TraceContextManager.getLocalContext()
-    ctx.db_opening = False
-
-    if not conf.profile_dbc_close:
-        try:
-            return fn(*args, **kwargs)
-        except Exception as e:
-            interceptor_step_error(e)
-        finally:
-            return
-    start_time = DateUtil.nowSystem()
-    ctx.start_time = start_time
-
-    try:
-        callback = fn(*args, **kwargs)
-        return callback
-    except Exception as e:
-        interceptor_step_error(e)
-    finally:
-        text = 'DB: Close Connection.'
-        datas = [' ', ' ', text]
-        ctx.elapsed = DateUtil.nowSystem() - start_time
-        async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
-
-
 check_seq = 1
 
 

{whatap_python-1.8.9.post0 → whatap_python-1.8.14}/whatap/trace/mod/database/cxoracle.py

@@ -1,6 +1,6 @@
 from whatap.trace import get_dict
-from whatap.trace.mod.application.wsgi import trace_handler, \
-    interceptor_db_con, interceptor_db_execute, interceptor_db_close
+from whatap.trace.mod.application.wsgi import trace_handler
+from whatap.trace.mod.database.util import interceptor_db_con, interceptor_db_execute, interceptor_db_close
 
 db_info = {}
 

{whatap_python-1.8.9.post0 → whatap_python-1.8.14}/whatap/trace/mod/database/mysql.py

@@ -1,7 +1,6 @@
 from whatap.trace import get_dict
-from whatap.trace.mod.application.wsgi import trace_handler, \
-    interceptor_db_con, interceptor_db_execute, interceptor_db_close
-
+from whatap.trace.mod.application.wsgi import trace_handler
+from whatap.trace.mod.database.util import interceptor_db_con, interceptor_db_execute, interceptor_db_close
 db_info = {}
 
 def instrument_MySQLdb(module):

whatap_python-1.8.14/whatap/trace/mod/database/neo4j.py

@@ -0,0 +1,90 @@
+from whatap.trace.mod.application.wsgi import trace_handler
+from whatap.trace.mod.database.util import interceptor_db_con, interceptor_db_execute, interceptor_db_close
+
+db_info = {}
+
+
+
+
+
+def instrument_neo4j(module):
+
+    if hasattr(module, 'GraphDatabase'):
+        orig_driver = module.GraphDatabase.driver
+        def wrapper(fn):
+            @trace_handler(fn)
+            def trace(*args, **kwargs):
+                db_info = {'type': 'neo4j'}
+
+                if args:
+                    db_info['uri'] = args[0]
+
+                auth = kwargs.get('auth') or (args[1] if len(args) > 1 else None)
+                if auth:
+                    user = getattr(auth, 'principal', None) or (auth[0] if isinstance(auth, tuple) else None)
+                    if user:
+                        db_info['user'] = user
+
+                callback = interceptor_db_con(fn, db_info, *args, **kwargs)
+                return callback
+
+            return trace
+        module.GraphDatabase.driver = wrapper(orig_driver)
+
+
+
+    if hasattr(module, 'Driver'):
+        orig_driver_close = module.Driver.close
+        def wrapper(fn):
+            @trace_handler(fn)
+            def trace(driver, *args, **kwargs):
+                callback = interceptor_db_close(fn, driver, *args, **kwargs)
+                return callback
+
+            return trace
+
+        module.Driver.close = wrapper(orig_driver_close)
+
+    orig = module.Session.run
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(session, *args, **kwargs):
+            db_info = {'type': 'neo4j'}
+            try:
+                setattr(session, 'rowcount', -1)
+            except Exception as e:
+                raise e
+            callback = interceptor_db_execute(fn, db_info, session, *args, **kwargs)
+
+            return callback
+        return trace
+    module.Session.run = wrapper(orig)
+
+    def wrapper(fn):
+        @trace_handler(fn)
+        def trace(tx, *args, **kwargs):
+            session = None
+            try:
+                session = tx._on_closed.__self__
+            except AttributeError:
+                return fn(tx, *args, **kwargs)
+            db_info = {'type': 'neo4j'}
+            try:
+                setattr(tx, 'rowcount', -1)
+            except Exception:
+                pass
+            callback = interceptor_db_execute(fn, db_info, tx, *args, **kwargs)
+            return callback
+
+        return trace
+
+    tx_classes_to_patch = ['Transaction', 'ManagedTransaction', 'BoltTransaction']
+    for class_name in tx_classes_to_patch:
+        if hasattr(module, class_name):
+            TxClass = getattr(module, class_name)
+            if hasattr(TxClass, 'run'):
+                original_run = getattr(TxClass, 'run')
+                setattr(TxClass, 'run', wrapper(original_run))
+
+
+

whatap_python-1.8.9.post0/whatap/trace/mod/database/postgresql.py → whatap_python-1.8.14/whatap/trace/mod/database/psycopg2.py

@@ -1,6 +1,6 @@
 from whatap.trace import get_dict
-from whatap.trace.mod.application.wsgi import trace_handler, \
-    interceptor_db_con, interceptor_db_execute, interceptor_db_close
+from whatap.trace.mod.application.wsgi import trace_handler
+from whatap.trace.mod.database.util import interceptor_db_con, interceptor_db_execute, interceptor_db_close
 
 db_info = {}