Trace method resolution order at runtime - django

Question

I am working on some code (not mine) and I try to instand it.
There 16 classes in the inheritance tree.
Here area the class according to inspect.getmro(self.__class__)
foo_barcheck.views.barcheck.AdminListActionView
foo_barcheck.views.barcheck.ListActionMixin
djangotools.utils.urlresolverutils.UrlMixin
foo.views.ListActionView
foo.views.ContextMixin
foo.views.fooMixin
djangotools.views.ListActionView
djangotools.views.ListViewMixin
django.views.generic.list.MultipleObjectMixin
django.views.generic.edit.FormMixin
djangotools.views.DTMixin
django.views.generic.base.TemplateView
django.views.generic.base.TemplateResponseMixin
django.views.generic.base.ContextMixin
django.views.generic.base.View
object
I want to trace what happens if I call self.do_magic().
I want to see all do_magic() calls of these 16 classes.
The ideal solution would look like this:
result_of_do_magic, list_of_do_magic_methods = trace_method_calls(self.do_magic)
I have no clue how to implement trace_method_calls(). It should execute the code and trace the method calls at runtime.
Is there a tracing guru which knows how to do this?
AFAIK this needs to be done at runtime, since I don't know if all methods calls the do_magic() of the parents via super().
Update
I don't want to modify the code to be able to trace it. I guess this should be possible, since the mocking library can do comparable magic.

Answer 1

If I understand correctly, I can see 2 solutions here.
1) [Brute-ish and relatively easy] Find all occurrences of "do_magic" in your code and wrap it with decorator like:
def trace_this(fn):
def wrapped(*args, **kwargs):
print("do_magic is called!")
result = fn(*args, **kwargs)
print("Result is:{0}".format(result))
return result
return wrapped
...
#trace_this
def do_magic():
...
2) Run django as:
python -m trace -t manage.py runserver 127.0.0.1:8000 --noreload > trace.txt
and all invoked code would be in trace.txt that you can then parse/analyze with tools you prefer.

Answer 2

According to my understanding what you want are the outer frames of a particular function call to see what classes were called to lead to the method in question.
If it is what you want continue below, else let me know in the comments:
Below is an POC to demonstrate how it works. You can build a decorator out of it.
from __future__ import print_function
import inspect
class A:
def a(self):
stacks = inspect.getouterframes(inspect.currentframe())
for stack in stacks:
frame = stack[0]
klass = frame.f_locals.get("self")
mthd = frame.f_code.co_name
if klass: # to avoid printing modules
print('Called by class: {0}, method: {1}'.format(klass.__class__.__name__, mthd))
class B:
def b(self):
bb = A()
bb.a()
class C:
def c(self):
cc = B()
cc.b()
z = C()
z.c()
Output:
Explanation:
Class C calls Class B which in turn calls Class A
When the execution reaches till A.a() all the classes that inherited A are in the outer frames.
You can extract out just the functionality of A.a() to carve out a decorator so that it will print all outer frames leading upto the function call.