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

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

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

whatap_python-1.8.11/whatap/build.py

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

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

@@ -1,7 +1,11 @@
+import inspect
+
 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,
-    async_interceptor_db_con, async_interceptor_db_execute, async_interceptor_db_close
+    async_interceptor_db_con, async_interceptor_db_execute, async_interceptor_db_close,
+    interceptor_pool_get, interceptor_pool_release,
+    async_interceptor_pool_get, async_interceptor_pool_release
 )
 
 db_info = {}
@@ -11,6 +15,7 @@ class BaseCursor:
     def __init__(self, cursor, db_info):
         self._cursor = cursor
         self._db_info = db_info
+        self._is_wrapped = True
 
     def __getattr__(self, name):
         return getattr(self._cursor, name)
@@ -45,28 +50,23 @@ class SyncCursor(BaseCursor):
         return self._cursor.__exit__(exc_type, exc_val, exc_tb)
 
     def execute(self, *args, **kwargs):
+        if hasattr(self._cursor, '_is_wrapped'):
+            return self._cursor.execute(*args, **kwargs)
         real_execute = self._cursor.execute
         safe_fn = self._execute_wrapper(real_execute)
-
-        callback = interceptor_db_execute(safe_fn,self._db_info,self._cursor,*args,**kwargs)
-
-        return callback
+        return interceptor_db_execute(safe_fn, self._db_info, self._cursor, *args, **kwargs)
 
     def executemany(self, *args, **kwargs):
+        if hasattr(self._cursor, '_is_wrapped'):
+            return self._cursor.executemany(*args, **kwargs)
         real_executemany = getattr(self._cursor, "executemany", None)
-
         if real_executemany is None:
             return self._cursor.executemany(*args, **kwargs)
-
         safe_fn = self._execute_wrapper(real_executemany)
-
-        callback = interceptor_db_execute(safe_fn,self._db_info,self._cursor,*args,**kwargs)
-
-        return callback
+        return interceptor_db_execute(safe_fn, self._db_info, self._cursor, *args, **kwargs)
 
 
 class AsyncCursor(BaseCursor):
-
     async def __aenter__(self):
         await self._cursor.__aenter__()
         return self
@@ -85,30 +85,27 @@ class AsyncCursor(BaseCursor):
         return async_safe_execute
 
     async def execute(self, *args, **kwargs):
+        if hasattr(self._cursor, '_is_wrapped'):
+            return await self._cursor.execute(*args, **kwargs)
         real_execute = self._cursor.execute
         safe_fn = self._async_execute_wrapper(real_execute)
-
-
-        callback = await async_interceptor_db_execute(safe_fn,self._db_info,self._cursor,*args,**kwargs)
-
-        return callback
+        return await async_interceptor_db_execute(safe_fn, self._db_info, self._cursor, *args, **kwargs)
 
     async def executemany(self, *args, **kwargs):
+        if hasattr(self._cursor, '_is_wrapped'):
+            return await self._cursor.executemany(*args, **kwargs)
         real_executemany = getattr(self._cursor, "executemany", None)
-
         if real_executemany is None:
             return await self._cursor.executemany(*args, **kwargs)
-
         safe_fn = self._async_execute_wrapper(real_executemany)
-
-        callback = await async_interceptor_db_execute(safe_fn,self._db_info,self._cursor,*args,**kwargs)
-        return callback
+        return await async_interceptor_db_execute(safe_fn, self._db_info, self._cursor, *args, **kwargs)
 
 
 class BaseConnection:
     def __init__(self, connection, db_info):
         self._connection = connection
         self._db_info = db_info
+        self._is_wrapped = True
 
     def __getattr__(self, name):
         return getattr(self._connection, name)
@@ -129,15 +126,8 @@ class BaseConnection:
 
         return safe_execute
 
-    def close(self, *args, **kwargs):
-        real_close = self._connection.close
-
-        callback = interceptor_db_close(real_close, *args, **kwargs)
-        return callback
-
 
 class SyncConnection(BaseConnection):
-
     def __enter__(self):
         self._connection.__enter__()
         return self
@@ -145,25 +135,31 @@ class SyncConnection(BaseConnection):
     def __exit__(self, exc_type, exc_val, exc_tb):
         return self._connection.__exit__(exc_type, exc_val, exc_tb)
 
+    def close(self, *args, **kwargs):
+        if self._db_info.get("pool"):
+            interceptor_pool_release()
+            return self._connection.close(*args, **kwargs)
+
+        real_close = self._connection.close
+        return interceptor_db_close(real_close, *args, **kwargs)
+
     def cursor(self, *args, **kwargs):
         real_cursor = self._connection.cursor(*args, **kwargs)
+        if hasattr(real_cursor, '_is_wrapped'):
+            return real_cursor
         return SyncCursor(real_cursor, self._db_info)
 
     def execute(self, *args, **kwargs):
+        if hasattr(self._connection, '_is_wrapped'):
+            return self._connection.execute(*args, **kwargs)
         real_execute = getattr(self._connection, "execute", None)
-
         if real_execute is None:
             return self._connection.execute(*args, **kwargs)
-
         safe_fn = self._execute_wrapper(real_execute)
-
-        callback = interceptor_db_execute(safe_fn,self._db_info,self._cursor,*args,**kwargs)
-
-        return callback
+        return interceptor_db_execute(safe_fn, self._db_info, self._connection, *args, **kwargs)
 
 
 class AsyncConnection(BaseConnection):
-
     async def __aenter__(self):
         await self._connection.__aenter__()
         return self
@@ -173,6 +169,8 @@ class AsyncConnection(BaseConnection):
 
     def cursor(self, *args, **kwargs):
         real_cursor = self._connection.cursor(*args, **kwargs)
+        if hasattr(real_cursor, '_is_wrapped'):
+            return real_cursor
         return AsyncCursor(real_cursor, self._db_info)
 
     def _async_execute_wrapper(self, original_execute_method):
@@ -186,66 +184,138 @@ class AsyncConnection(BaseConnection):
         return async_safe_execute
 
     async def execute(self, *args, **kwargs):
+        if hasattr(self._connection, '_is_wrapped'):
+            return await self._connection.execute(*args, **kwargs)
         real_execute = getattr(self._connection, "execute", None)
-
         if real_execute is None:
             return await self._connection.execute(*args, **kwargs)
-
         safe_fn = self._async_execute_wrapper(real_execute)
-
-        callback = await async_interceptor_db_execute(safe_fn,self._db_info,self._connection,*args,**kwargs)
-
-        return callback
+        return await async_interceptor_db_execute(safe_fn, self._db_info, self._connection, *args, **kwargs)
 
     async def close(self, *args, **kwargs):
+        if self._db_info.get("pool"):
+            await async_interceptor_pool_release()
+            return await self._connection.close(*args, **kwargs)
+
         real_close = self._connection.close
+        return await async_interceptor_db_close(real_close, *args, **kwargs)
 
-        callback =  await async_interceptor_db_close(real_close, *args, **kwargs)
 
-        return callback
+def _is_called_by_pool():
+    try:
+        # 실제로 psycopg_pool은 보통 3-4 레벨 내에서 호출되므로 깊이 5로 결정.
+        filenames = [f.filename for f in inspect.stack(context=0)[2:7]]
+        return any('psycopg_pool' in f for f in filenames if f)
+    except Exception:
+        return False
 
 
 def _sync_wrapper(fn):
-
     @trace_handler(fn)
     def wrapper(*args, **kwargs):
-        global db_info
+        if _is_called_by_pool():
+            return fn(*args, **kwargs)
 
         db_info = {"type": "postgresql"}
+
+        if args and isinstance(args[0], str) and '=' in args[0]:
+            conn_str = args[0]
+            parsed_kwargs = dict(
+                x.split('=') for x in conn_str.split()
+            )
+            kwargs.update(parsed_kwargs)
+
         db_info.update(kwargs)
 
         connection = interceptor_db_con(fn, db_info, *args, **kwargs)
-
+        if hasattr(connection, '_is_wrapped'):
+            return connection
         return SyncConnection(connection, dict(db_info))
 
     return wrapper
 
 
 def _async_wrapper(fn):
-
     @trace_handler(fn)
     async def wrapper(*args, **kwargs):
-        global db_info
+        if _is_called_by_pool():
+            return await fn(*args, **kwargs)
 
         db_info = {"type": "postgresql"}
-        db_info.update(kwargs)
 
-        connection = await async_interceptor_db_con(fn,db_info,*args,**kwargs)
+        if args and isinstance(args[0], str) and '=' in args[0]:
+            conn_str = args[0]
+            parsed_kwargs = dict(
+                x.split('=') for x in conn_str.split()
+            )
+            kwargs.update(parsed_kwargs)
+
+        db_info.update(kwargs)
 
+        connection = await async_interceptor_db_con(fn, db_info, *args, **kwargs)
+        if hasattr(connection, '_is_wrapped'):
+            return connection
         return AsyncConnection(connection, dict(db_info))
 
     return wrapper
 
 
-def instrument_psycopg3(module):
-    original_connect = module.connect
+def _get_conn_info(connection):
+    conn_info = {}
+    try:
+        if hasattr(connection, 'info'):
+            conn_info['host'] = connection.info.host
+            conn_info['port'] = connection.info.port
+            conn_info['dbname'] = connection.info.dbname
+            conn_info['user'] = connection.info.user
+        elif hasattr(connection, 'dsn'):
+            import re
+            dsn_params = dict(x.split('=') for x in re.sub(r'\s*=\s*', '=', connection.dsn).split())
+            conn_info.update(dsn_params)
+    except Exception as e:
+        print(f"Failed to extract connection info: {e}")
+    return conn_info
+
+
+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)
+        db_info = {"type": "postgresql", "pool": True, **conn_info}
+
+        interceptor_pool_get(db_info)
+
+        return SyncConnection(connection, db_info)
+
+    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)
+        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)
+
+    return wrapper
+
+
+def instrument_psycopg(module):
+    original_connect = module.connect
     module.connect = _sync_wrapper(original_connect)
+    if hasattr(module, 'AsyncConnection') and hasattr(module.AsyncConnection, 'connect'):
+        original_async_connect = module.AsyncConnection.connect
+        module.AsyncConnection.connect = _async_wrapper(original_async_connect)
 
-    if hasattr(module, 'AsyncConnection'):
-        async_conn = module.AsyncConnection
 
-        if hasattr(async_conn, 'connect'):
-            original_async_connect = async_conn.connect
-            async_conn.connect = _async_wrapper(original_async_connect)
+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)
 

{whatap_python-1.8.10 → whatap_python-1.8.11}/whatap/trace/mod/database/sqlalchemy.py

@@ -49,7 +49,7 @@ def instrument_sqlalchemy_engine(module):
             query = None
             if len(args) > 3 and args[3]:
                 try:
-                    ##oracledb 에서 orm 툴로 sqlalchemy 사용하는 경우
+                    ##oracle을 사용하는 경우
                     if (type(args[3]) == dict) and (":" in args[2]) and ("oracle" in str(args[0])):
                         oracle_sql_query = args[2]
                         for k, v in args[3].items():
@@ -59,8 +59,8 @@ def instrument_sqlalchemy_engine(module):
                                                                         replaced_value) if replaced_key in oracle_sql_query else None
                         query = oracle_sql_query
 
-                    ##aiomysql 에서 orm 툴로 sqlalchemy 사용하는 경우
-                    elif (type(args[3]) == tuple) and ("%s" in args[2]) and ("aiomysql" in str(args[0])):
+                    ##mysql를 사용하는 경우
+                    elif (type(args[3]) == tuple) and ("%s" in args[2]) and ("mysql" in str(args[0])):
                         my_sql_query = args[2]
                         for v in args[3]:
                             replaced_value = f"'{v}'"
@@ -79,7 +79,7 @@ def instrument_sqlalchemy_engine(module):
                 query = str(args[2])
             # print('instrument_sqlalchemy_engine 3:', query)
             sqlalchemy_track_skip = False
-            except_track_module = ['pymysql', 'mysqldb', 'psycopg2']
+            except_track_module = ['pymysql', 'mysqldb', 'psycopg2','psycopg','sqlite3']
 
             # 이미 DB드라이브 추적 모듈이 존재하면 sqlAlhechmy 의 추적 중지
             if any(keyword in str(args[0]) for keyword in except_track_module):

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

@@ -63,7 +63,6 @@ def addQuoteMany(arg_list, query_template=None):
     Returns:
         str: 포매팅된 문자열
     """
-    print(arg_list)
     if not arg_list:
         return ""
 
@@ -110,7 +109,6 @@ def addQuoteMany(arg_list, query_template=None):
 
             result = ";\n".join(queries)
 
-        print(result)
         return result
 
     except Exception as e:
@@ -228,7 +226,6 @@ def interceptor_db_execute(fn, db_info, *args, **kwargs):
     self = args[0]
     db_type = db_info.get('type')
     query = None
-
     if db_type == "neo4j":
         try:
             query = neo4jQuery(args[1], kwargs)
@@ -332,8 +329,6 @@ def interceptor_db_close(fn, *args, **kwargs):
         async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
 
 
-# ===== 비동기 버전 (새로 추가) =====
-
 async def async_interceptor_db_con(fn, db_info, *args, **kwargs):
     ctx = TraceContextManager.getLocalContext()
     if not ctx:
@@ -381,7 +376,6 @@ async def async_interceptor_db_execute(fn, db_info, *args, **kwargs):
     self = args[0]
     db_type = db_info.get('type')
     query = None
-
     if db_type == "neo4j":
         try:
             query = neo4jQuery(args[1], kwargs)
@@ -491,4 +485,67 @@ async def async_interceptor_db_close(fn, *args, **kwargs):
         text = 'DB: Close Connection.'
         datas = [' ', ' ', text]
         ctx.elapsed = DateUtil.nowSystem() - start_time
-        async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+        async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+
+
+def interceptor_pool_get(db_info):
+    ctx = TraceContextManager.getLocalContext()
+    if not ctx:
+        return
+
+    start_time = DateUtil.nowSystem()
+
+    db_type = db_info.get('type', 'db')
+    text = f"{db_type}://{db_info.get('user', '')}@{db_info.get('host', '')}/{db_info.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)
+
+
+def interceptor_pool_release():
+    ctx = TraceContextManager.getLocalContext()
+    if not ctx or not conf.profile_dbc_close:
+        return
+
+    start_time = DateUtil.nowSystem()
+    text = 'DB: Close Connection.'
+    datas = [' ', ' ', text]
+    ctx.elapsed = DateUtil.nowSystem() - start_time
+    async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)
+
+
+async def async_interceptor_pool_get(db_info):
+    ctx = TraceContextManager.getLocalContext()
+    if not ctx:
+        return
+
+    start_time = DateUtil.nowSystem()
+
+    db_type = db_info.get('type', 'db')
+    text = f"{db_type}://{db_info.get('user', '')}@{db_info.get('host', '')}/{db_info.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)
+
+async def async_interceptor_pool_release():
+    ctx = TraceContextManager.getLocalContext()
+    if not ctx or not conf.profile_dbc_close:
+        return
+
+    start_time = DateUtil.nowSystem()
+    text = 'DB: Close Connection.'
+    datas = [' ', ' ', text]
+    ctx.elapsed = DateUtil.nowSystem() - start_time
+    async_sender.send_packet(PacketTypeEnum.TX_MSG, ctx, datas)

{whatap_python-1.8.10 → whatap_python-1.8.11}/whatap/trace/trace_module_definition.py

@@ -57,7 +57,8 @@ DEFINITION = {
         ('psycopg2.extensions', 'instrument_psycopg2_extensions'),
     ],
     'database.psycopg3': [
-        ('psycopg', 'instrument_psycopg3')
+        ('psycopg', 'instrument_psycopg'),
+        ('psycopg_pool', 'instrument_psycopg_pool'),
     ],
 
     'database.neo4j': [

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

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

whatap_python-1.8.10/whatap/build.py

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