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

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

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

whatap_python-1.8.10/whatap/build.py

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

{whatap_python-1.8.9.post0 → whatap_python-1.8.10}/whatap/trace/mod/application/wsgi.py

@@ -263,6 +263,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 +302,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 +367,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.10}/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.10}/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.10/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.10/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 = {}
 

whatap_python-1.8.10/whatap/trace/mod/database/psycopg3.py

@@ -0,0 +1,251 @@
+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
+)
+
+db_info = {}
+
+
+class BaseCursor:
+    def __init__(self, cursor, db_info):
+        self._cursor = cursor
+        self._db_info = db_info
+
+    def __getattr__(self, name):
+        return getattr(self._cursor, name)
+
+    def __setattr__(self, name, value):
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._cursor, name, value)
+
+    @property
+    def connection(self):
+        return self._cursor.connection
+
+    def _execute_wrapper(self, original_execute_method):
+        owner = getattr(original_execute_method, "__self__", None)
+
+        def safe_execute(*args, **kwargs):
+            if args and owner is not None and args[0] is owner:
+                args = args[1:]
+            return original_execute_method(*args, **kwargs)
+
+        return safe_execute
+
+
+class SyncCursor(BaseCursor):
+    def __enter__(self):
+        self._cursor.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return self._cursor.__exit__(exc_type, exc_val, exc_tb)
+
+    def execute(self, *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
+
+    def executemany(self, *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
+
+
+class AsyncCursor(BaseCursor):
+
+    async def __aenter__(self):
+        await self._cursor.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return await self._cursor.__aexit__(exc_type, exc_val, exc_tb)
+
+    def _async_execute_wrapper(self, original_execute_method):
+        owner = getattr(original_execute_method, "__self__", None)
+
+        async def async_safe_execute(*args, **kwargs):
+            if args and owner is not None and args[0] is owner:
+                args = args[1:]
+            return await original_execute_method(*args, **kwargs)
+
+        return async_safe_execute
+
+    async def execute(self, *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
+
+    async def executemany(self, *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
+
+
+class BaseConnection:
+    def __init__(self, connection, db_info):
+        self._connection = connection
+        self._db_info = db_info
+
+    def __getattr__(self, name):
+        return getattr(self._connection, name)
+
+    def __setattr__(self, name, value):
+        if name.startswith('_'):
+            object.__setattr__(self, name, value)
+        else:
+            setattr(self._connection, name, value)
+
+    def _execute_wrapper(self, original_execute_method):
+        owner = getattr(original_execute_method, "__self__", None)
+
+        def safe_execute(*args, **kwargs):
+            if args and owner is not None and args[0] is owner:
+                args = args[1:]
+            return original_execute_method(*args, **kwargs)
+
+        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
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return self._connection.__exit__(exc_type, exc_val, exc_tb)
+
+    def cursor(self, *args, **kwargs):
+        real_cursor = self._connection.cursor(*args, **kwargs)
+        return SyncCursor(real_cursor, self._db_info)
+
+    def execute(self, *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
+
+
+class AsyncConnection(BaseConnection):
+
+    async def __aenter__(self):
+        await self._connection.__aenter__()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        return await self._connection.__aexit__(exc_type, exc_val, exc_tb)
+
+    def cursor(self, *args, **kwargs):
+        real_cursor = self._connection.cursor(*args, **kwargs)
+        return AsyncCursor(real_cursor, self._db_info)
+
+    def _async_execute_wrapper(self, original_execute_method):
+        owner = getattr(original_execute_method, "__self__", None)
+
+        async def async_safe_execute(*args, **kwargs):
+            if args and owner is not None and args[0] is owner:
+                args = args[1:]
+            return await original_execute_method(*args, **kwargs)
+
+        return async_safe_execute
+
+    async def execute(self, *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
+
+    async def close(self, *args, **kwargs):
+        real_close = self._connection.close
+
+        callback =  await async_interceptor_db_close(real_close, *args, **kwargs)
+
+        return callback
+
+
+def _sync_wrapper(fn):
+
+    @trace_handler(fn)
+    def wrapper(*args, **kwargs):
+        global db_info
+
+        db_info = {"type": "postgresql"}
+        db_info.update(kwargs)
+
+        connection = interceptor_db_con(fn, db_info, *args, **kwargs)
+
+        return SyncConnection(connection, dict(db_info))
+
+    return wrapper
+
+
+def _async_wrapper(fn):
+
+    @trace_handler(fn)
+    async def wrapper(*args, **kwargs):
+        global db_info
+
+        db_info = {"type": "postgresql"}
+        db_info.update(kwargs)
+
+        connection = await async_interceptor_db_con(fn,db_info,*args,**kwargs)
+
+        return AsyncConnection(connection, dict(db_info))
+
+    return wrapper
+
+
+def instrument_psycopg3(module):
+    original_connect = module.connect
+
+    module.connect = _sync_wrapper(original_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)
+

whatap_python-1.8.9.post0/whatap/trace/mod/database/toolkit.py → whatap_python-1.8.10/whatap/trace/mod/database/sqlalchemy.py

@@ -1,6 +1,6 @@
 from whatap.net.packet_type_enum import PacketTypeEnum
 import whatap.net.async_sender as async_sender
-from whatap.trace.mod.application.wsgi import trace_handler, interceptor_db_execute, interceptor_step_error, sendDebugProfile
+from whatap.trace.mod.application.wsgi import trace_handler, interceptor_step_error, sendDebugProfile
 from whatap.util.date_util import DateUtil
 from whatap.trace.trace_context_manager import TraceContextManager
 import sys

{whatap_python-1.8.9.post0 → whatap_python-1.8.10}/whatap/trace/mod/database/sqlite3.py

@@ -1,5 +1,5 @@
-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
 
 class CursorProxy:
     def __init__(self, real_cursor, db_info):