Add CallRecordingPanel

Author: dcramer

debug_toolbar/panels/__init__.py

@@ -6,6 +6,8 @@
 
 from debug_toolbar import settings as dt_settings
 from debug_toolbar.utils import get_name_from_obj
+from debug_toolbar.utils.function_wrapper import FunctionWrapper
+from debug_toolbar.utils.patch_context import PatchContext
 
 
 class Panel(object):
@@ -171,3 +173,33 @@ class DebugPanel(Panel):
     def __init__(self, *args, **kwargs):
         warnings.warn("DebugPanel was renamed to Panel.", DeprecationWarning)
         super(DebugPanel, self).__init__(*args, **kwargs)
+
+
+class CallRecordingPanel(Panel):
+    def __init__(self, *args, **kwargs):
+        super(CallRecordingPanel, self).__init__(*args, **kwargs)
+        self.calls = []
+        self._context = []
+
+        for context in self.get_context():
+            self.add_context(context)
+
+    def get_context(self):
+        """
+        >>> def get_context(self):
+        >>>     return [
+        >>>         PatchContext('foo.bar', FunctionWrapper(self.calls))
+        >>>     ]
+        """
+        raise NotImplementedError
+
+    def add_context(self, context):
+        self._context.append(context)
+
+    def enable_instrumentation(self):
+        for context in self._context:
+            context.patch()
+
+    def disable_instrumentation(self):
+        for context in self._context:
+            context.unpatch()

debug_toolbar/utils.py renamed to debug_toolbar/utils/__init__.py

@@ -0,0 +1,36 @@
+from __future__ import absolute_import
+
+from time import time
+
+
+class FunctionWrapper(object):
+    def __init__(self, data):
+        self.data = data
+
+    def __call__(self, func, *args, **kwargs):
+        __traceback_hide__ = True  # NOQA
+
+        start = time()
+        try:
+            return func(*args, **kwargs)
+        finally:
+            end = time()
+
+            if getattr(func, 'im_class', None):
+                arg_str = repr(args[1:])
+            else:
+                arg_str = repr(args)
+
+            data = {
+                'type': self.name or func.__name__,
+                'name': func.__name__,
+                'args': arg_str,
+                'kwargs': repr(kwargs),
+                'start': start,
+                'end': end,
+            }
+
+            self.record(data)
+
+    def record(self, data):
+        self.data.append(data)

debug_toolbar/utils/function_wrapper.py

@@ -0,0 +1,55 @@
+from __future__ import absolute_import
+
+
+def _dot_lookup(thing, comp, import_path):
+    try:
+        return getattr(thing, comp)
+    except AttributeError:
+        __import__(import_path)
+        return getattr(thing, comp)
+
+
+def import_string(target):
+    components = target.split('.')
+    import_path = components.pop(0)
+    thing = __import__(import_path)
+
+    for comp in components:
+        import_path += ".%s" % comp
+        thing = _dot_lookup(thing, comp, import_path)
+    return thing
+
+
+class PatchContext(object):
+    def __init__(self, target, callback):
+        target, attr = target.rsplit('.', 1)
+        target = import_string(target)
+        self.func = getattr(target, attr)
+        self.target = target
+        self.attr = attr
+        self.callback = callback
+
+    def __enter__(self):
+        self.patch()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.unpatch()
+
+    def patch(self):
+        func = getattr(self.target, self.attr)
+
+        def wrapped(*args, **kwargs):
+            __traceback_hide__ = True  # NOQA
+            return self.callback(self.func, *args, **kwargs)
+
+        wrapped.__name__ = func.__name__
+        if hasattr(func, '__doc__'):
+            wrapped.__doc__ = func.__doc__
+        if hasattr(func, '__module__'):
+            wrapped.__module__ = func.__module__
+
+        setattr(self.target, self.attr, wrapped)
+
+    def unpatch(self):
+        setattr(self.target, self.attr, self.func)