Flask应用API请求变量全状态跟踪问题及替代方案咨询

我正尝试在Flask应用的API请求中跟踪所有变量，目标是监控这些变量的前后状态。我编写了如下代码，但未达到预期效果，能否提供使用locals()或其他方法实现该需求的替代方案？

from flask import Flask, jsonify, request
from functools import wraps

app = Flask(__name__)

def track_changes(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # Initial values dictionary
        initial_values = {k: v for k, v in locals().items() if k not in ['func', 'request', 'response']}

        result = func(*args, **kwargs)

        # Final values dictionary
        final_values = {k: v for k, v in locals().items() if k not in ['func', 'request', 'response']}

        # Identify and log changes
        changes = {k: (v1, v2) for k, (v1, v2) in zip(initial_values.keys(), zip(initial_values.values(), final_values.values())) if v1 != v2}

        print ("initial values==>", initial_values)
        print ("final values", final_values)
        if changes:
            print(f"Function: {func.__name__}")
            print("Changes:", changes)

        return result

    return wrapper


@app.route('/hello', methods=['GET'])
@track_changes
def hello():
# Modify value based on request data
    initial_value = 10  # Assuming a default initial value
    new_value = initial_value + 1
    initial_value = 20
    new_value = initial_value

    # Log changes without explicitly creating a class instance
    print(f"Initial value: {initial_value}, New value: {new_value}")
    return jsonify({'message': 'Hello, World!'})

# ...

if __name__ == '__main__':
    app.run(debug=True)

你写的装饰器里的locals()只能获取wrapper函数自身的局部变量（比如args、kwargs、result），无法访问被装饰的hello()函数内部的变量——因为两个函数属于不同的作用域，所以自然监控不到目标函数的变量变化。

方案1：动态注入捕获逻辑（无需修改目标函数） #

通过动态修改目标函数的源代码，在函数开头和返回前插入变量捕获逻辑，自动对比前后状态：

from flask import Flask, jsonify, request
from functools import wraps
import sys
import inspect

app = Flask(__name__)

def track_changes(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        # 定义捕获目标函数局部变量的辅助函数
        def capture_vars():
            # 获取上一级帧（目标函数的执行帧）
            frame = sys._getframe(1)
            return frame.f_locals.copy()
        
        # 读取目标函数的源代码
        source = inspect.getsource(func)
        func_name = func.__name__
        
        # 在函数开头插入初始变量捕获代码
        source = source.replace(f'def {func_name}():', 
                               f'def {func_name}():\n    _initial_vars = capture_vars()')
        
        # 在返回语句前插入最终变量捕获与对比代码
        return_line_start = 'return jsonify'
        if return_line_start in source:
            compare_code = f'''    _final_vars = capture_vars()
    # 对比变量变化
    changes = {{k: (_initial_vars[k], _final_vars[k]) for k in _initial_vars 
               if k in _final_vars and _initial_vars[k] != _final_vars[k]}}
    if changes:
        print(f"Function: {func_name}")
        print("变量变化:", changes)
    '''
            source = source.replace(return_line_start, compare_code + return_line_start)
        
        # 执行修改后的代码，获取修改后的函数
        local_scope = {}
        exec(source, globals(), local_scope)
        modified_func = local_scope[func_name]
        
        return modified_func(*args, **kwargs)
    return wrapper

@app.route('/hello', methods=['GET'])
@track_changes
def hello():
    initial_value = 10
    new_value = initial_value + 1
    initial_value = 20
    new_value = initial_value

    print(f"当前值: initial_value={initial_value}, new_value={new_value}")
    return jsonify({'message': 'Hello, World!'})

if __name__ == '__main__':
    app.run(debug=True)

启动后访问/hello，控制台会输出：

当前值: initial_value=20, new_value=20
Function: hello
变量变化: {'initial_value': (10, 20), 'new_value': (11, 20)}

方案2：手动标记监控点（更灵活） #

如果不想动态修改代码，可以在目标函数的关键位置手动调用监控函数，自定义捕获时机：

from flask import Flask, jsonify, request
from functools import wraps

app = Flask(__name__)

def track_vars(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        initial_vars = None
        final_vars = None
        
        # 定义捕获初始变量的函数
        def capture_initial():
            nonlocal initial_vars
            initial_vars = locals().copy()
        
        # 定义捕获最终变量并对比的函数
        def capture_final():
            nonlocal final_vars
            final_vars = locals().copy()
            changes = {k: (initial_vars[k], final_vars[k]) for k in initial_vars 
                       if k in final_vars and initial_vars[k] != final_vars[k]}
            if changes:
                print(f"Function: {func.__name__}")
                print("变量变化:", changes)
        
        # 将捕获函数传入目标函数
        kwargs['_capture_initial'] = capture_initial
        kwargs['_capture_final'] = capture_final
        return func(*args, **kwargs)
    return wrapper

@app.route('/hello', methods=['GET'])
@track_vars
def hello(**kwargs):
    # 取出捕获函数
    _capture_initial = kwargs.pop('_capture_initial')
    _capture_final = kwargs.pop('_capture_final')
    
    # 初始化变量后捕获初始状态
    initial_value = 10
    new_value = initial_value + 1
    _capture_initial()
    
    # 修改变量
    initial_value = 20
    new_value = initial_value
    
    # 修改完成后捕获最终状态并对比
    _capture_final()
    
    print(f"当前值: initial_value={initial_value}, new_value={new_value}")
    return jsonify({'message': 'Hello, World!'})

if __name__ == '__main__':
    app.run(debug=True)

这个方案的优势是你可以在任意需要监控的位置调用_capture_initial()和_capture_final()，比如在复杂业务逻辑的中间步骤捕获变量状态。

内容的提问来源于stack exchange，提问作者dhananjay_shingote