backlash 0.4.0__py3-none-any.whl

backlash/__init__.py

@@ -0,0 +1,3 @@
+from backlash.debug import DebuggedApplication
+from backlash.tracing.errors import TraceErrorsMiddleware
+from backlash.tracing.slowrequests import TraceSlowRequestsMiddleware

backlash/_compat.py

@@ -0,0 +1,78 @@
+import sys
+import types
+
+# True if we are running on Python 3.
+PY3 = sys.version_info[0] == 3
+PY2 = sys.version_info[0] == 2
+
+if PY3: # pragma: no cover
+    string_types = str,
+    integer_types = int,
+    class_types = type,
+    text_type = str
+    binary_type = bytes
+    long = int
+else:
+    string_types = basestring,
+    integer_types = (int, long)
+    class_types = (type, types.ClassType)
+    text_type = unicode
+    binary_type = str
+    long = long
+
+def text_(s, encoding='utf-8', errors='strict'):
+    if isinstance(s, binary_type):
+        return s.decode(encoding, errors)
+    return s # pragma: no cover
+
+def bytes_(s, encoding='utf-8', errors='strict'):
+    if isinstance(s, text_type):
+        return s.encode(encoding, errors)
+    return s
+
+if PY3: # pragma: no cover
+    def native_(s, encoding='latin-1', errors='strict'):
+        if isinstance(s, text_type):
+            return s
+        return str(s, encoding, errors)
+else:
+    def native_(s, encoding='latin-1', errors='strict'):
+        if isinstance(s, text_type): # pragma: no cover
+            return s.encode(encoding, errors)
+        return str(s)
+
+if PY3: # pragma: no cover
+    def iteritems_(d):
+        return d.items()
+else:
+    def iteritems_(d):
+        return d.iteritems()
+
+if PY3: # pragma: no cover
+    import builtins
+    exec_ = getattr(builtins, "exec")
+    def reraise(exc_info):
+        etype, exc, tb = exc_info
+        if exc.__traceback__ is not tb:
+            raise exc.with_traceback(tb)
+        raise exc
+else: # pragma: no cover
+    def exec_(code, globs=None, locs=None):
+        """Execute code in a namespace."""
+        if globs is None:
+            frame = sys._getframe(1)
+            globs = frame.f_globals
+            if locs is None:
+                locs = frame.f_locals
+            del frame
+        elif locs is None:
+            locs = globs
+        exec("""exec code in globs, locs""")
+    exec_("""def reraise(exc_info):
+    raise exc_info[0], exc_info[1], exc_info[2]
+""")
+
+try:
+    from urllib2 import urlopen
+except ImportError:
+    from urllib.request import urlopen

backlash/console.py

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+"""
+    werkzeug.debug.console
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Interactive console support.
+
+    :copyright: (c) 2011 by the Werkzeug Team, see AUTHORS for more details.
+    :license: BSD.
+"""
+import sys
+import code
+from types import CodeType
+import threading
+
+from backlash._compat import exec_, text_, binary_type
+from backlash.utils import escape
+from backlash.repr import debug_repr, dump, helper
+
+_local = threading.local()
+
+class HTMLStringO(object):
+    """A StringO version that HTML escapes on write."""
+
+    def __init__(self):
+        self._buffer = []
+
+    def isatty(self):
+        return False
+
+    def close(self):
+        pass
+
+    def flush(self):
+        pass
+
+    def seek(self, n, mode=0):
+        pass
+
+    def readline(self):
+        if len(self._buffer) == 0:
+            return ''
+        ret = self._buffer[0]
+        del self._buffer[0]
+        return ret
+
+    def reset(self):
+        val = ''.join(self._buffer)
+        del self._buffer[:]
+        return val
+
+    def _write(self, x):
+        if isinstance(x, binary_type):
+            x = text_(x, 'utf-8', 'replace')
+        self._buffer.append(x)
+
+    def write(self, x):
+        self._write(escape(x))
+
+    def writelines(self, x):
+        self._write(escape(''.join(x)))
+
+
+class ThreadedStream(object):
+    """Thread-local wrapper for sys.stdout for the interactive console."""
+
+    def push():
+        if not isinstance(sys.stdout, ThreadedStream):
+            sys.stdout = ThreadedStream()
+        _local.stream = HTMLStringO()
+    push = staticmethod(push)
+
+    def fetch():
+        try:
+            stream = _local.stream
+        except AttributeError:
+            return ''
+        return stream.reset()
+    fetch = staticmethod(fetch)
+
+    def displayhook(obj):
+        try:
+            stream = _local.stream
+        except AttributeError:
+            return _displayhook(obj)
+            # stream._write bypasses escaping as debug_repr is
+        # already generating HTML for us.
+        if obj is not None:
+            stream._write(debug_repr(obj))
+    displayhook = staticmethod(displayhook)
+
+    def __setattr__(self, name, value):
+        raise AttributeError('read only attribute %s' % name)
+
+    def __dir__(self):
+        return dir(sys.__stdout__)
+
+    def __getattribute__(self, name):
+        if name == '__members__':
+            return dir(sys.__stdout__)
+        try:
+            stream = _local.stream
+        except AttributeError:
+            stream = sys.__stdout__
+        return getattr(stream, name)
+
+    def __repr__(self):
+        return repr(sys.__stdout__)
+
+
+# add the threaded stream as display hook
+_displayhook = sys.displayhook
+sys.displayhook = ThreadedStream.displayhook
+
+
+class _ConsoleLoader(object):
+
+    def __init__(self):
+        self._storage = {}
+
+    def register(self, code, source):
+        self._storage[id(code)] = source
+        # register code objects of wrapped functions too.
+        for var in code.co_consts:
+            if isinstance(var, CodeType):
+                self._storage[id(var)] = source
+
+    def get_source_by_code(self, code):
+        try:
+            return self._storage[id(code)]
+        except KeyError:
+            pass
+
+
+def _wrap_compiler(console):
+    compile = console.compile
+    def func(source, filename, symbol):
+        code = compile(source, filename, symbol)
+        console.loader.register(code, source)
+        return code
+    console.compile = func
+
+
+class _InteractiveConsole(code.InteractiveInterpreter):
+
+    def __init__(self, globals, locals, context):
+        code.InteractiveInterpreter.__init__(self, locals)
+        self.globals = dict(globals)
+        self.globals['dump'] = dump
+        self.globals['help'] = helper
+        self.globals['ctx'] = context
+        self.globals['__loader__'] = self.loader = _ConsoleLoader()
+        self.more = False
+        self.buffer = []
+        _wrap_compiler(self)
+
+    def runsource(self, source):
+        source = source.rstrip() + '\n'
+        ThreadedStream.push()
+        prompt = self.more and '... ' or '>>> '
+        try:
+            source_to_eval = ''.join(self.buffer + [source])
+            if code.InteractiveInterpreter.runsource(self,
+                source_to_eval, '<debugger>', 'single'):
+                self.more = True
+                self.buffer.append(source)
+            else:
+                self.more = False
+                del self.buffer[:]
+        finally:
+            output = ThreadedStream.fetch()
+        return prompt + source + output
+
+    def runcode(self, code):
+        try:
+            exec_(code, self.globals, self.locals)
+        except Exception:
+            self.showtraceback()
+
+    def showtraceback(self):
+        from backlash.tbtools import get_current_traceback
+        tb = get_current_traceback(skip=1)
+        sys.stdout._write(tb.render_summary())
+
+    def showsyntaxerror(self, filename=None):
+        from backlash.tbtools import get_current_traceback
+        tb = get_current_traceback(skip=4)
+        sys.stdout._write(tb.render_summary())
+
+    def write(self, data):
+        sys.stdout.write(data)
+
+
+class Console(object):
+    """An interactive console."""
+
+    def __init__(self, globals=None, locals=None, context=None):
+        if locals is None:
+            locals = {}
+        if globals is None:
+            globals = {}
+        self._ipy = _InteractiveConsole(globals, locals, context)
+
+    def eval(self, code):
+        return self._ipy.runsource(code)
+
+class _ConsoleFrame(object):
+    """Helper class so that we can reuse the frame console code for the
+    standalone console.
+    """
+    def __init__(self, namespace):
+        self.console = Console(namespace)
+        self.id = 0

backlash/debug.py

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+"""
+    werkzeug.debug
+    ~~~~~~~~~~~~~~
+
+    WSGI application traceback debugger.
+
+    :copyright: (c) 2011 by the Werkzeug Team, see AUTHORS for more details.
+    :license: BSD.
+"""
+import mimetypes
+import json
+from os.path import join, dirname, basename, isfile
+
+from webob import Request, Response
+
+from backlash.tbtools import get_current_traceback, render_console_html
+from backlash.console import Console
+from backlash.utils import gen_salt, RequestContext
+
+import logging
+log = logging.getLogger('backlash')
+
+
+class _ConsoleFrame(object):
+    """Helper class so that we can reuse the frame console code for the
+    standalone console.
+    """
+
+    def __init__(self, namespace):
+        self.console = Console(namespace)
+        self.id = 0
+
+
+class DebuggedApplication(object):
+    """Enables debugging support for a given application::
+
+        from backlash.debug import DebuggedApplication
+        from myapp import app
+        app = DebuggedApplication(app, evalex=True)
+
+    The `evalex` keyword argument allows evaluating expressions in a
+    traceback's frame context.
+
+    :param app: the WSGI application to run debugged.
+    :param evalex: enable exception evaluation feature (interactive
+                   debugging).  This requires a non-forking server.
+    :param console_path: the URL for a general purpose console.
+    :param console_init_func: the function that is executed before starting
+                              the general purpose console.  The return value
+                              is used as initial namespace.
+    :param show_hidden_frames: by default hidden traceback frames are skipped.
+                               You can show them by setting this parameter
+                               to `True`.
+    """
+    def __init__(self, app, evalex=True, console_path='/__console__',
+                 console_init_func=None, show_hidden_frames=False,
+                 lodgeit_url=None, context_injectors=None):
+        if not console_init_func:
+            console_init_func = dict
+        self.app = app
+        self.evalex = evalex
+        self.frames = {}
+        self.tracebacks = {}
+        self.console_path = console_path
+        self.console_init_func = console_init_func
+        self.show_hidden_frames = show_hidden_frames
+        self.secret = gen_salt(20)
+        self.context_injectors = context_injectors or []
+
+        if lodgeit_url is not None:
+            from warnings import warn
+            warn(DeprecationWarning('Backlash now pastes into gists.'))
+
+    def debug_application(self, environ, start_response):
+        """Run the application and conserve the traceback frames."""
+        app_iter = None
+        try:
+            try:
+                app_iter = self.app(environ, start_response)
+                for item in app_iter:
+                    yield item
+            finally:
+                if hasattr(app_iter, 'close'):
+                    app_iter.close()
+        except Exception:
+            context = RequestContext({'environ':dict(environ)})
+            for injector in self.context_injectors:
+                context.update(injector(environ))
+
+            traceback = get_current_traceback(skip=1, show_hidden_frames=self.show_hidden_frames,
+                                              context=context)
+            for frame in traceback.frames:
+                self.frames[frame.id] = frame
+            self.tracebacks[traceback.id] = traceback
+
+            try:
+                start_response('500 INTERNAL SERVER ERROR', [
+                    ('Content-Type', 'text/html; charset=utf-8'),
+                    # Disable Chrome's XSS protection, the debug
+                    # output can cause false-positives.
+                    ('X-XSS-Protection', '0'),
+                    ])
+            except Exception:
+                # if we end up here there has been output but an error
+                # occurred.  in that situation we can do nothing fancy any
+                # more, better log something into the error log and fall
+                # back gracefully.
+                environ['wsgi.errors'].write(
+                    'Debugging middleware caught exception in streamed '
+                    'response at a point where response headers were already '
+                    'sent.\n')
+            else:
+                yield traceback.render_full(
+                    evalex=self.evalex,
+                    secret=self.secret
+                ).encode('utf-8', 'replace')
+
+            # This will lead to double logging in case backlash logger is set to DEBUG
+            # but this is actually wanted as some environments, like WebTest, swallow
+            # wsgi.environ making the traceback totally disappear.
+            log.debug(traceback.plaintext)
+            traceback.log(environ['wsgi.errors'])
+
+    def execute_command(self, request, command, frame):
+        """Execute a command in a console."""
+        return Response(frame.console.eval(command), content_type='text/html')
+
+    def display_console(self, request):
+        """Display a standalone shell."""
+        if 0 not in self.frames:
+            self.frames[0] = _ConsoleFrame(self.console_init_func())
+        return Response(render_console_html(secret=self.secret),
+            content_type='text/html')
+
+    def paste_traceback(self, request, traceback):
+        """Paste the traceback and return a JSON response."""
+        rv = traceback.paste()
+        return Response(json.dumps(rv), content_type='application/json')
+
+    def get_source(self, request, frame):
+        """Render the source viewer."""
+        return Response(frame.render_source(), content_type='text/html')
+
+    def get_resource(self, request, filename):
+        """Return a static resource from the shared folder."""
+        filename = join(dirname(__file__), 'statics', basename(filename))
+        if isfile(filename):
+            mimetype = mimetypes.guess_type(filename)[0]\
+            or 'application/octet-stream'
+            f = open(filename, 'rb')
+            try:
+                return Response(f.read(), content_type=mimetype)
+            finally:
+                f.close()
+        return Response('Not Found', status=404)
+
+    def __call__(self, environ, start_response):
+        """Dispatch the requests."""
+        # important: don't ever access a function here that reads the incoming
+        # form data!  Otherwise the application won't have access to that data
+        # any more!
+        request = Request(environ)
+        response = self.debug_application
+        if request.GET.get('__debugger__') == 'yes':
+            cmd = request.GET.get('cmd')
+            arg = request.GET.get('f')
+            secret = request.GET.get('s')
+
+            tb = request.GET.get('tb')
+            if tb is not None:
+                tb = int(tb)
+            traceback = self.tracebacks.get(tb)
+
+            frm = request.GET.get('frm')
+            if frm is not None:
+                frm = int(frm)
+            frame = self.frames.get(frm)
+
+            if cmd == 'resource' and arg:
+                response = self.get_resource(request, arg)
+            elif cmd == 'paste' and traceback is not None and\
+                 secret == self.secret:
+                response = self.paste_traceback(request, traceback)
+            elif cmd == 'source' and frame and self.secret == secret:
+                response = self.get_source(request, frame)
+            elif self.evalex and cmd is not None and frame is not None and\
+                 self.secret == secret:
+                response = self.execute_command(request, cmd, frame)
+        elif self.evalex and self.console_path is not None and\
+             request.path == self.console_path:
+            response = self.display_console(request)
+        return response(environ, start_response)

backlash/frtools.py

@@ -0,0 +1,27 @@
+import sys, inspect
+from .tbtools import Traceback, Frame
+
+
+class DumpThread(Exception):
+    backlash_event = True
+
+
+def get_thread_stack(thread_id, description='', error_type=DumpThread, context=None):
+    if isinstance(error_type, str):
+        error_type = type(error_type, (DumpThread,), {})
+        # Hack to prevent traceback module from printing
+        # backlash.frtools.ExceptionName instead of just ExceptionName
+        error_type.__module__ = '__main__'
+
+    e = error_type(description)
+    tb = Traceback(error_type, e, [], context=context)
+
+    f = sys._current_frames()[thread_id]
+    n = 0
+    while f is not None:
+        if inspect.isframe(f):
+            tb.frames.insert(0, Frame(error_type, e, f, context))
+        f = f.f_back
+        n += 1
+
+    return tb