如何跟踪类中的所有方法调用？

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class MethodTracer {
    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        MyClass tracedClass = (MyClass) createTracedInstance(myClass);
        tracedClass.method1();
        tracedClass.method2();
    }

    public static Object createTracedInstance(Object target) {
        return Proxy.newProxyInstance(
            target.getClass().getClassLoader(),
            target.getClass().getInterfaces(),
            new MethodTracingInvocationHandler(target)
        );
    }

    private static class MethodTracingInvocationHandler implements InvocationHandler {
        private final Object target;

        public MethodTracingInvocationHandler(Object target) {
            this.target = target;
        }

        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Entering method: " + method.getName());
            Object result = method.invoke(target, args);
            System.out.println("Exiting method: " + method.getName());
            return result;
        }
    }
}

class MyClass {
    public void method1() {
        System.out.println("Inside method1");
    }

    public void method2() {
        System.out.println("Inside method2");
    }
}

import inspect

class MyClass:
    def method1(self):
        print("Inside method1")

    def method2(self):
        print("Inside method2")

class MethodTracer:
    def __init__(self, obj):
        self.obj = obj

    def __getattr__(self, name):
        method = getattr(self.obj, name)
        if inspect.ismethod(method):
            def traced_method(*args, **kwargs):
                print(f"Entering method: {name}")
                result = method(*args, **kwargs)
                print(f"Exiting method: {name}")
                return result
            return traced_method
        else:
            return method

traced_obj = MethodTracer(MyClass())
traced_obj.method1()
traced_obj.method2()