# 偽代碼
def my_execute(conn, sql, param):
 # 針對(duì)MySql庫(kù)的統(tǒng)計(jì)封裝組件
 with MyTracer(conn, sql, param):
     # 以下為正常使用MySql庫(kù)的代碼
with conn.cursor as cursor:
?cursor.execute(sql, param)
...

import importlib
import sys
from functools import wraps
def func_wrapper(func):
    """這里通過(guò)一個(gè)裝飾器來(lái)達(dá)到貍貓換太子和獲取數(shù)據(jù)的效果"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 記錄開(kāi)始時(shí)間
        start = time.time()
        result = func(*args, **kwargs)
        # 統(tǒng)計(jì)消耗時(shí)間
        end = time.time()
        print(f"speed time:{end - start}")
        return result
    return wrapper
class MetaPathFinder:
    def find_module(self, fullname, path=None):
        # 執(zhí)行時(shí)可以看出來(lái)在import哪些模塊
        print(f'find module:{path}:{fullname}')
        return MetaPathLoader()
class MetaPathLoader:
    def load_module(self, fullname):
        # import的模塊都會(huì)存放在sys.modules里面， 通過(guò)判斷可以減少重復(fù)import
        if fullname in sys.modules:
            return sys.modules[fullname]
        # 防止遞歸調(diào)用
        finder = sys.meta_path.pop(0)
        # 導(dǎo)入 module
        module = importlib.import_module(fullname)
        if fullname == 'time':
            # 替換函數(shù)
            module.sleep = func_wrapper(module.sleep)
        sys.meta_path.insert(0, finder)
        return module
sys.meta_path.insert(0, MetaPathFinder())
if __name__ == '__main__':
    import time
    time.sleep(1)
# 輸出示例:
# find module:datetime
# find module:time
# load module:time
# find module:math
# find module:_datetime
# speed time:1.00073385238647468

async def execute(self, query, args=None):
    """Executes the given operation
    Executes the given operation substituting any markers with
    the given parameters.
    For example, getting all rows where id is 5:
        cursor.execute("SELECT * FROM t1 WHERE id = %s", (5,))
    :param query: ``str`` sql statement
    :param args: ``tuple`` or ``list`` of arguments for sql query
    :returns: ``int``, number of rows that has been produced of affected
    """
    conn = self._get_db()

    while (await self.nextset()):
        pass

    if args is not None:
        query = query % self._escape_args(args, conn)

    await self._query(query)
    self._executed = query
    if self._echo:
        logger.info(query)
        logger.info("%r", args)
    return self._rowcount

def fetchone(self):
    """Fetch the next row """
    self._check_executed()
    fut = self._loop.create_future()
    if self._rows is None or self._rownumber >= len(self._rows):
        fut.set_result(None)
        return fut
    result = self._rows[self._rownumber]
    self._rownumber += 1
    fut = self._loop.create_future()
    fut.set_result(result)
    return fut

import importlib
import time
import sys
from functools import wraps
from typing import cast, Any, Callable, Optional, Tuple, TYPE_CHECKING
from types import ModuleType
if TYPE_CHECKING:
    import aiomysql
def func_wrapper(func: Callable):
    @wraps(func)
    async def wrapper(*args, **kwargs) -> Any:
        start: float = time.time()
        func_result: Any = await func(*args, **kwargs)
        end: float = time.time()
        # 根據(jù)_query可以知道, 第一格參數(shù)是self, 第二個(gè)參數(shù)是sql
        self: aiomysql.Cursor = args[0]
        sql: str = args[1]
        # 通過(guò)self,我們可以拿到其他的數(shù)據(jù)
        db: str = self._connection.db
        user: str = self._connection.user
        host: str = self._connection.host
        port: str = self._connection.port
        execute_result: Tuple[Tuple] = self._rows
        # 可以根據(jù)自己定義的agent把數(shù)據(jù)發(fā)送到指定的平臺(tái), 然后我們就可以在平臺(tái)上看到對(duì)應(yīng)的數(shù)據(jù)或進(jìn)行監(jiān)控了, 
        # 這里只是打印一部分?jǐn)?shù)據(jù)出來(lái)
        print({
            "sql": sql,
            "db": db,
            "user": user,
            "host": host,
            "port": port,
            "result": execute_result,
            "speed time": end - start
        })
        return func_result
    return cast(Callable, wrapper)
class MetaPathFinder:

    @staticmethod
    def find_module(fullname: str, path: Optional[str] = None) -> Optional["MetaPathLoader"]:
        if fullname == 'aiomysql':
            # 只有aiomysql才進(jìn)行hook
            return MetaPathLoader()
        else:
            return None
class MetaPathLoader:
    @staticmethod
    def load_module(fullname: str):
        if fullname in sys.modules:
            return sys.modules[fullname]
        # 防止遞歸調(diào)用
        finder: "MetaPathFinder" = sys.meta_path.pop(0)
        # 導(dǎo)入 module
        module: ModuleType = importlib.import_module(fullname)
        # 針對(duì)_query進(jìn)行hook
        module.Cursor._query = func_wrapper(module.Cursor._query)
        sys.meta_path.insert(0, finder)
        return module
async def test_mysql() -> None:
    import aiomysql
    pool: aiomysql.Pool = await aiomysql.create_pool(
        host='127.0.0.1', port=3306, user='root', password='123123', db='mysql'
    )
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            await cur.execute("SELECT 42;")
            (r,) = await cur.fetchone()
            assert r == 42
    pool.close()
    await pool.wait_closed()

if __name__ == '__main__':
    sys.meta_path.insert(0, MetaPathFinder())
    import asyncio
    asyncio.run(test_mysql())
# 輸出示例:
# 可以看出sql語(yǔ)句與我們輸入的一樣, db, user, host, port等參數(shù)也是, 還能知道執(zhí)行的結(jié)果和運(yùn)行時(shí)間
# {'sql': 'SELECT 42;', 'db': 'mysql', 'user': 'root', 'host': '127.0.0.1', 'port': 3306, 'result': ((42,),), 'speed time': 0.00045609474182128906}

.
├── __init__.py
├── hook_aiomysql.py
├── sitecustomize.py
└── test_auto_hook.py

import sys
from hook_aiomysql import MetaPathFinder
sys.meta_path.insert(0, MetaPathFinder())

import asyncio
from hook_aiomysql import test_mysql
asyncio.run(test_mysql())

(.venv) ?  python_hook git:(master) ? export PYTHONPATH=.      
(.venv) ?  python_hook git:(master) ? python test_auto_hook.py 
{'sql': 'SELECT 42;', 'db': 'mysql', 'user': 'root', 'host': '127.0.0.1', 'port': 3306, 'result': ((42,),), 'speed time': 0.000213623046875}

class MetaPathLoader:
    def load_module(self, fullname):
        # import的模塊都會(huì)存放在sys.modules里面， 通過(guò)判斷可以減少重復(fù)import
        if fullname in sys.modules:
            return sys.modules[fullname]
        # 防止遞歸調(diào)用
        finder = sys.meta_path.pop(0)
        # 導(dǎo)入 module
        module = importlib.import_module(fullname)
        if fullname == 'time':
            # 替換函數(shù)
            module.sleep = func_wrapper(module.sleep)
        sys.meta_path.insert(0, finder)
        return module

import time
from functools import wraps
from typing import Any, Callable, Tuple, cast
import aiomysql
def func_wrapper(func: Callable):
    """和上面一樣的封裝函數(shù), 這里簡(jiǎn)單略過(guò)"""
# 判斷是否hook過(guò)
_IS_HOOK: bool = False
# 存放原來(lái)的_query
_query: Callable = aiomysql.Cursor._query
# hook函數(shù)
def install_hook() -> None:
    _IS_HOOK = False
    if _IS_HOOK:
        return
    aiomysql.Cursor._query = func_wrapper(aiomysql.Cursor._query)
    _IS_HOOK = True
# 還原到原來(lái)的函數(shù)方法
def reset_hook() -> None:
    aiomysql.Cursor._query = _query
    _IS_HOOK = False

import asyncio
import aiomysql
from demo import install_hook, reset_hook
async def test_mysql() -> None:
    pool: aiomysql.Pool = await aiomysql.create_pool(
        host='127.0.0.1', port=3306, user='root', password='', db='mysql'
    )
    async with pool.acquire() as conn:
        async with conn.cursor() as cur:
            await cur.execute("SELECT 42;")
            (r,) = await cur.fetchone()
            assert r == 42
    pool.close()
    await pool.wait_closed()

print("install hook")
install_hook()
asyncio.run(test_mysql())
print("reset hook")
reset_hook()
asyncio.run(test_mysql())
print("end")

install hook
{'sql': 'SELECT 42;', 'db': 'mysql', 'user': 'root', 'host': '127.0.0.1', 'port': 3306, 'result': ((42,),), 'speed time': 0.000347137451171875}
reset hook
end