tgext.debugbar 0.6.0__py3-none-any.whl

tgext/debugbar/__init__.py

@@ -0,0 +1,17 @@
+from .initialize import DebugBar, enable_debugbar
+
+
+def plugme(app_config, options):
+    try:
+        app_config.update_blueprint({
+            'debugbar.inventing': options.get('inventing', False),
+            'debugbar.inventing_css': options.get('inventing_css', True),
+            'debugbar.enable_logs': options.get('enable_logs', False)
+        })
+    except AttributeError:
+        app_config['debugbar.inventing'] = options.get('inventing', False)
+        app_config['debugbar.inventing_css'] = options.get('inventing_css', True)
+        app_config['debugbar.enable_logs'] = options.get('enable_logs', False)
+    
+    enable_debugbar(app_config)
+    return dict(appid='tgext.debugbar')

tgext/debugbar/controller.py

@@ -0,0 +1,117 @@
+import sys
+import os
+import pprint
+import json
+
+from tg import app_globals, config, expose, request
+from tg.controllers import TGController, WSGIAppController
+from webob.exc import HTTPBadRequest
+from .utils import format_sql, format_json
+from .sections import __sections__
+
+STATICS_PATH = os.path.join(os.path.split(sys.modules['tgext.debugbar'].__file__)[0], 'statics')
+
+
+try:
+    from webob.static import DirectoryApp
+except ImportError:
+    from paste.urlparser import StaticURLParser as DirectoryApp
+
+try:
+    from pymongo import json_util
+except ImportError:
+    try:
+        from bson import json_util
+    except ImportError:
+        pass
+
+
+class StaticsController(TGController):
+    _directory_app = DirectoryApp(STATICS_PATH)
+
+    @expose()
+    def _default(self, *args):
+        new_req = request.copy()
+        to_pop = len(new_req.path_info.strip('/').split('/')) - len(args)
+        for i in range(to_pop):
+            new_req.path_info_pop()
+        return new_req.get_response(self._directory_app)
+
+
+class DebugBarController(TGController):
+    statics = StaticsController()
+
+    @expose('genshi:tgext.debugbar.templates.perform_sql!html')
+    @expose('kajiki:tgext.debugbar.templates.perform_sql!html')
+    def perform_sql(self, stmt, params, engine_id, duration, modify=None):
+        # Make sure it is a select statement
+        if not stmt.lower().lstrip().startswith('select'):
+            raise HTTPBadRequest('Not a SELECT SQL statement')
+        try:
+            if not engine_id:
+                raise ValueError
+            engine_id = int(engine_id)
+            engine = getattr(app_globals, 'tgdb_sqla_engines')[engine_id]()
+        except (AttributeError, IndexError, ValueError):
+            raise HTTPBadRequest('No valid database engine')
+
+        if modify and modify.lower() == 'explain':
+            if engine.name.startswith('sqlite'):
+                stmt = 'EXPLAIN QUERY PLAN %s' % stmt
+            else:
+                stmt = 'EXPLAIN %s' % stmt
+            title = 'Execution Plan'
+        else:
+            title = 'Query Results'
+
+        sql_params = json.loads(params)
+        if isinstance(sql_params, list):
+            sql_params = tuple(sql_params)
+
+        with engine.connect() as connection:
+            result = connection.exec_driver_sql(stmt, sql_params)
+            rows = result.fetchall()
+            headers = result.keys()
+
+        return dict(
+            sql=format_sql(stmt),
+            params=params,
+            result=rows,
+            headers=headers,
+            duration=float(duration),
+            title=title)
+
+    @expose('genshi:tgext.debugbar.templates.perform_ming!html')
+    @expose('kajiki:tgext.debugbar.templates.perform_ming!html')
+    def perform_ming(self, collection, command, params, duration, modify=None):
+        if not command.startswith('find'):
+            raise HTTPBadRequest('Not a find statement')
+
+        query_params = json.loads(params, object_hook=json_util.object_hook)
+        session = config['package'].model.DBSession
+
+        cursor = []
+        for i, step in enumerate(command.split('.')):
+            if step == 'find':
+                args = query_params[i]
+                query = args[0]
+                options = args[1]
+                cursor = session.find(collection, query, **options)
+            else:
+                args = query_params[i]
+                cmd = getattr(cursor, step)
+                cursor = cmd(*args)
+
+        isexplain = False
+        if modify and modify.lower() == 'explain':
+            cursor = cursor.ming_cursor.cursor.explain()
+            isexplain = True
+
+        return dict(
+            pformat=pprint.pformat,
+            action=command,
+            params=format_json(params),
+            result=cursor,
+            collection=collection,
+            duration=float(duration),
+            isexplain=isexplain)

tgext/debugbar/initialize.py

@@ -0,0 +1,151 @@
+import logging
+
+from markupsafe import Markup
+
+import tg
+from tg import request, url
+from tg.render import render
+
+try:
+    # Verify that we have hooks with disconnect feature,
+    # which is only available since TG2.3.5, otherwise
+    # use app_config to register/disconnect hooks.
+    from tg import hooks as tg_hooks
+    if not hasattr(tg_hooks, 'disconnect'):
+        tg_hooks = None
+except ImportError:
+    tg_hooks = None
+
+try:
+    # TG >= 2.4
+    from tg import ApplicationConfigurator
+except ImportError:
+    # TG < 2.4
+    class ApplicationConfigurator: pass
+
+from tgext.debugbar.sections import __sections__
+from tgext.debugbar.utils import get_root_controller
+
+log = logging.getLogger('tgext.debugbar')
+
+
+class DebugBar():
+    css_link = '<link rel="stylesheet" type="text/css" href="%s" />'
+    css_path = '/_debugbar/statics/style.css'
+    template = 'tgext.debugbar.templates.debugbar!html'
+
+    def __init__(self, app_config):
+        self.app_config = app_config
+        self.available_engines = None
+
+    def _register_hook(self, hook_name, handler):
+        if tg_hooks is None:
+            # 2.1+
+            self.app_config.register_hook(hook_name, handler)
+        elif hasattr(tg_hooks, 'wrap_controller'):
+            # 2.3+
+            if hook_name == 'controller_wrapper':
+                def _accept_decoration(decoration, controller):
+                    return handler(controller)
+                tg_hooks.wrap_controller(_accept_decoration)
+            else:
+                tg_hooks.register(hook_name, handler)
+        else:
+            # 2.4+
+            if hook_name == 'controller_wrapper':
+                from tg import ApplicationConfigurator
+                dispatch = ApplicationConfigurator.current().get_component('dispatch')
+                if dispatch is None:
+                    raise RuntimeError('TurboGears application configured without dispatching')
+                dispatch.register_controller_wrapper(handler)
+            else:
+                tg_hooks.register(hook_name, handler)
+
+    def _disconnect_hook(self, hook_name, handler):
+        if tg_hooks is None:
+            self.app_config.hooks[hook_name].remove(handler)
+        else:
+            tg_hooks.disconnect(hook_name, handler)
+
+    def __call__(self, configurator=None, conf=None):
+        if conf is None:
+            conf = tg.config
+        
+        if not conf.get('debug', False):
+            return
+
+        conf['debugbar.engine'] = next(
+            iter(sorted(set(('genshi', 'kajiki')) & set(conf['renderers']),
+                        key=lambda x: x == conf['default_renderer'],
+                        reverse=True)),
+            None
+        )
+        if not conf['debugbar.engine']:
+            log.error("Genshi or Kajiki rendering engines unavailable. Please install kajiki "
+                      "and add base_config.renderers.append('kajiki') to your app_cfg.py")
+            raise RuntimeError('Debugbar requires Genshi or Kajiki rendering engines')
+
+        log.log(logging.INFO, 'Enabling Debug Toolbar')
+        for sec in __sections__:
+            if not sec.is_active:
+                continue
+
+            log.log(logging.DEBUG, 'Enabling Section: %s' % sec.name)
+            for hook_name, hooks in sec.hooks.items():
+                for handler in hooks:
+                    if hook_name == 'startup':
+                        handler()
+                    else:
+                        try:
+                            self._register_hook(hook_name, handler)
+                        except:
+                            log.exception('Unable to register hook: %s', hook_name)
+
+        self._register_hook('after_render', self.render_first)
+
+    def render_first(self, response):
+        try:
+            self._disconnect_hook('after_render', self.render_first)
+        except ValueError:
+            pass  # pre-emptied by another request
+        else:
+            from tgext.debugbar.controller import DebugBarController
+            get_root_controller()._debugbar = DebugBarController()
+            self._register_hook('after_render', self.render_bars)
+        self.render_bars(response)
+
+    def render_bars(self, response):
+        page = response.get('response')
+        if (not page or not isinstance(page, str)
+                or 'text/html' not in response['content_type']
+                or request.headers.get(
+                    'X-Requested-With') == 'XMLHttpRequest'):
+
+            if tg.config.get('debugbar.enable_logs', False):
+                for section in __sections__:
+                    if hasattr(section, 'log_content'):
+                        section.log_content()
+
+            return
+
+        pos_head = page.find('</head>')
+        if pos_head > 0:
+            pos_body = page.find('</body>', pos_head + 7)
+            if pos_body > 0:
+                response['response'] = ''.join(
+                    [page[:pos_head],
+                    Markup(self.css_link % url(self.css_path)),
+                    page[pos_head:pos_body],
+                    Markup(render(dict(sections=__sections__),
+                                  tg.config['debugbar.engine'], self.template,).split('\n', 1)[-1]),
+                    page[pos_body:]])
+
+
+def enable_debugbar(app_config):
+    if isinstance(app_config, ApplicationConfigurator):
+        tg_hooks.register('initialized_config', DebugBar(app_config))
+    else:
+        if tg_hooks is None:
+            app_config.register_hook('startup', DebugBar(app_config))
+        else:
+            tg_hooks.register('startup', DebugBar(app_config))

tgext/debugbar/sections/__init__.py

@@ -0,0 +1,17 @@
+from .sqla import SQLADebugSection
+from .timing import TimingDebugSection
+from .request_vars import RequestDebugSection
+from .controllers import ControllersDebugSection
+from .logmessages import LoggingDebugSection
+from .mingorm import MingDebugSection
+from .inventing import InventingDebugSection
+
+__sections__ = [
+    TimingDebugSection(),
+    RequestDebugSection(),
+    SQLADebugSection(),
+    MingDebugSection(),
+    ControllersDebugSection(),
+    LoggingDebugSection(),
+    InventingDebugSection()
+]

tgext/debugbar/sections/base.py

@@ -0,0 +1,20 @@
+"""The base debug section class."""
+
+
+class DebugSection(object):
+
+    name = "Unnamed"
+    is_active = False
+    hooks = dict(
+        startup=[],
+        shutdown=[],
+        before_validate=[],
+        before_call=[],
+        before_render=[],
+        after_render=[])
+
+    def title(self):
+        raise NotImplementedError
+
+    def content(self):
+        raise NotImplementedError

tgext/debugbar/sections/controllers.py

@@ -0,0 +1,49 @@
+import inspect
+
+import tg
+from tg.controllers.decoratedcontroller import DecoratedController
+from tg.i18n import ugettext as _
+from tg.render import render
+
+try:
+    from tg.util import odict
+except ImportError:
+    from collections import OrderedDict as odict
+
+from tgext.debugbar.sections.base import DebugSection
+from tgext.debugbar.utils import get_root_controller
+
+
+def map_controllers(path, controller, output):
+    if inspect.isclass(controller):
+        if not issubclass(controller, DecoratedController):
+            return
+    else:
+        if isinstance(controller, DecoratedController):
+            controller = controller.__class__
+        else:
+            return
+
+    exposed_methods = {}
+    output[path and path or '/'] = dict(
+        controller=controller, exposed_methods=exposed_methods)
+    for name, cont in controller.__dict__.items():
+        if hasattr(cont, 'decoration') and cont.decoration.exposed:
+            exposed_methods[name] = cont
+        map_controllers(path + '/' + name, cont, output)
+
+
+class ControllersDebugSection(DebugSection):
+    name = 'Controllers'
+    is_active = True
+
+    def title(self):
+        return _('Controllers')
+
+    def content(self):
+        controllers = odict()
+        map_controllers('', get_root_controller(), controllers)
+        return str(render(
+            dict(controllers=controllers),
+            tg.config['debugbar.engine'], 'tgext.debugbar.sections.templates.controllers!html'
+            ).split('\n', 1)[-1])

tgext/debugbar/sections/inventing.py

@@ -0,0 +1,198 @@
+import hashlib, re, logging, os, time
+from datetime import datetime
+from tg import config, tmpl_context
+from tg.render import render
+from tg.i18n import ugettext as _
+
+from paste.deploy.converters import asbool
+from tgext.debugbar.sections.base import DebugSection
+
+from markupsafe import Markup
+
+log = logging.getLogger('tgext.debugbar')
+
+_reload_datetime = datetime.now().strftime('%Y%m%d%H%M%S')
+_href_re = re.compile(r'''href=["\']([^\'\"]+)[\'"]''', re.UNICODE|re.IGNORECASE)
+
+def detect_stylesheets(page):
+    try:
+        base_dir = config.get('paths', config.get('pylons.paths'))['static_files']
+    except:
+        log.warn('Unable to detect static files path, skipping inventing mode on stylesheets')
+        return []
+
+    files = []
+
+    line = page.find('stylesheet')
+    while line >= 0:
+        css_link = _href_re.search(page[line:])
+        if css_link:
+            css_file = css_link.group(1)
+            css_file = css_file.replace('/', os.sep)
+            if css_file.startswith(os.sep):
+                css_file = css_file[1:]
+
+            css_file = os.path.join(base_dir, css_file)
+            if os.path.exists(css_file):
+                files.append(css_file)
+        line = page.find('stylesheet', line+1)
+
+    return files
+
+def on_after_render(response, *args, **kw):
+    content_type = response.get('content_type', '')
+    template = response.get('template_name')
+    page = response.get('response')
+
+    if content_type and 'text/html' in content_type and template and isinstance(page, str):
+        m = hashlib.md5()
+        m.update(page.encode('utf-8'))
+        m = m.hexdigest() + _reload_datetime
+
+        if config.get('debugbar.inventing_css', False):
+            newest_modified_time = 0
+
+            for f in detect_stylesheets(page):
+                modified_time = os.path.getmtime(f)
+                if modified_time > newest_modified_time:
+                    newest_modified_time = modified_time
+
+            if newest_modified_time:
+                m += str(newest_modified_time)
+
+        pos_head = page.find('</head>')
+        if pos_head > 0:
+            pos_body = page.find('</body>', pos_head + 7)
+            if pos_body > 0:
+                response['response'] = ''.join([page[:pos_head],
+                                                Markup('<script>if(typeof tgext_debugbar_page_hash === "undefined") window.tgext_debugbar_page_hash="%s";</script>' % m),
+                                                page[pos_head:pos_body],
+                                                page[pos_body:]])
+
+class InventingDebugSection(DebugSection):
+    name = 'Inventing'
+    is_active = True
+    hooks = dict(after_render=[on_after_render])
+
+    js_reloadscript = '''
+<script>
+; (function(win, undefined) {
+    var tgext_debugbar_inventing = win['tgext_debugbar_inventing'] = (win['tgext_debugbar_inventing'] || {});
+
+    tgext_debugbar_inventing.start = function() {
+        if (!supportsLocalStorage()) {
+            alert("Inventing Mode requires local storage support");
+            return false;
+        }
+
+        localStorage["tgext.debugbar.enabled"] = "true";
+        DebugBarJQuery('#tgdb_debugbar_inventing_toggle').text('Turn Off');
+        tgext_debugbar_inventing.loop();
+    };
+
+    tgext_debugbar_inventing.loop = function() {
+        if (!tgext_debugbar_inventing.is_enabled())
+            return;
+
+        setTimeout(tgext_debugbar_check_changed, 1000);
+    };
+
+    tgext_debugbar_inventing.is_enabled = function() {
+        if (!supportsLocalStorage())
+            return false;
+
+        var enabled = (localStorage["tgext.debugbar.enabled"] == "true");
+        return enabled;
+    }
+
+    tgext_debugbar_inventing.init = function(force) {
+        var enabled = (tgext_debugbar_inventing.is_enabled() || force);
+        if (!enabled)
+            return false;
+
+        tgext_debugbar_inventing.start();
+        return true;
+    };
+
+    tgext_debugbar_inventing.toggle = function(button) {
+        if (!supportsLocalStorage()) {
+            alert("Inventing Mode requires local storage support");
+            return false;
+        }
+
+        button = DebugBarJQuery(button);
+
+        var debugbar_enabled = tgext_debugbar_inventing.is_enabled();
+        if (!debugbar_enabled) {
+            tgext_debugbar_inventing.start();
+            button.text('Turn Off');
+        }
+        else {
+            localStorage["tgext.debugbar.enabled"] = "false";
+            button.text('Turn On');
+        }
+    };
+
+    function tgext_debugbar_check_changed() {
+        DebugBarJQuery.ajax(window.location.href, {
+            'success': function(data, textStatus, jqXHR) {
+                var page_hash_re = /tgext_debugbar_page_hash="(.*)";/;
+                var page_hash = page_hash_re.exec(data);
+                if (page_hash && page_hash.length) {
+                    var page_hash = page_hash[1];
+                    if(page_hash != tgext_debugbar_page_hash) {
+                        window.location.reload();
+                        return
+                    }
+                }
+                DebugBarJQuery('#tgdb_debugbar #tgdb_barcontent').removeClass('tgdb_barcontent_error');
+                DebugBarJQuery('#tgdb_debugbar #tgdb_barcontent').removeClass('tgdb_barcontent_warning');
+                tgext_debugbar_inventing.loop();
+            },
+            'error':function(jqXHR, textStatus, errorThrown) {
+                DebugBarJQuery('#tgdb_debugbar #tgdb_barcontent').removeClass('tgdb_barcontent_error');
+                DebugBarJQuery('#tgdb_debugbar #tgdb_barcontent').removeClass('tgdb_barcontent_warning');
+
+                if (jqXHR.status && jqXHR.status >= 500) {
+                    DebugBarJQuery('#tgdb_debugbar #tgdb_barcontent').addClass('tgdb_barcontent_error');
+                }
+                else if (jqXHR.status && jqXHR.status < 500) {
+                    //Probably not an error in this case, yet to decide if to alert it somehow
+                }
+                else {
+                    DebugBarJQuery('#tgdb_debugbar #tgdb_barcontent').addClass('tgdb_barcontent_warning');
+                }
+                tgext_debugbar_inventing.loop();
+            }
+        });
+    }
+
+    function supportsLocalStorage() {
+      try {
+        return 'localStorage' in window && window['localStorage'] !== null;
+      } catch(e){
+        return false;
+      }
+    }
+})(window);
+</script>'''
+
+    def title(self):
+        return _('Inventing')
+
+    def content(self):
+        inventing_enabled = asbool(config.get('debugbar.inventing', 'false'))
+        inventing_enabled = getattr(tmpl_context, 'debugbar_inventing', inventing_enabled)
+
+        result = ''
+        result += render(dict(), config['debugbar.engine'],
+                         'tgext.debugbar.sections.templates.inventing!html')
+
+        result += Markup(self.js_reloadscript)
+        if inventing_enabled:
+            result += Markup('<script>tgext_debugbar_inventing.init(true)</script>')
+        else:
+            result += Markup('<script>tgext_debugbar_inventing.init(false)</script>')
+
+        return result
+

tgext/debugbar/sections/logmessages.py

@@ -0,0 +1,69 @@
+import datetime
+import logging
+import threading
+
+import tg
+from tg.i18n import ugettext as _
+from tg.render import render
+
+from tgext.debugbar.sections.base import DebugSection
+from tgext.debugbar.utils import format_fname
+
+
+class ThreadTrackingHandler(logging.Handler):
+    def __init__(self):
+        logging.Handler.__init__(self)
+        self.records = {}
+
+    def emit(self, record):
+        self.get_records().append(record)
+
+    def get_records(self, thread=None):
+        if thread is None:
+            thread = threading.current_thread()
+        if thread not in self.records:
+            self.records[thread] = []
+        return self.records[thread]
+
+    def clear_records(self, thread=None):
+        if thread is None:
+            thread = threading.current_thread()
+        if thread in self.records:
+            del self.records[thread]
+
+handler = ThreadTrackingHandler()
+logging.root.addHandler(handler)
+
+
+class LoggingDebugSection(DebugSection):
+    name = 'Logging'
+    is_active = True
+
+    def get_and_clear(self):
+        records = handler.get_records()
+        handler.clear_records()
+        return records
+
+    def title(self):
+        return _('Logging')
+
+    def content(self):
+        records = []
+        for record in self.get_and_clear():
+            msg = record.getMessage()
+            if isinstance(msg, bytes):
+                msg = msg.decode('utf-8', 'ignore')
+            records.append({
+                'message': msg,
+                'time': datetime.datetime.fromtimestamp(record.created),
+                'level': record.levelname,
+                'file': format_fname(record.pathname),
+                'file_long': record.pathname,
+                'line': record.lineno,
+            })
+
+        records = reversed(records)
+        return str(render(
+            dict(records=records),
+            tg.config['debugbar.engine'], 'tgext.debugbar.sections.templates.logging!html'
+            ).split('\n', 1)[-1])