Tag Archives: debug

by

Trace db queries in Django shell 

import logging
l = logging.getLogger('django.db.backends')
l.setLevel(logging.DEBUG)
l.addHandler(logging.StreamHandler())

or use this command (requires Django Debug Toolbar installed):

$ python manage.py debugsqlshell

or add this to your settings:

#
# LOGGING
#

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '%(levelname)s %(asctime)s %(module)s %(process)d %(thread)d %(message)s'
        },
        'simple': {
            'format': '%(levelname)s %(message)s'
        },
    },
    'handlers': {
        # 'file': {
        #     'level': 'DEBUG',
        #     'class': 'logging.FileHandler',
        #     'filename': '/home/aecweb/logs/django.log',
        # },
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'formatter': 'simple'
        },
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console', ],
            'level': 'DEBUG',
        },
    },
}
by

manageex.py: Print all queries to console during Django debug session

file “manageex.py”

#!/usr/bin/env python
import os
import sys
from django.db.backends import util

#
# Purpose: act like 'manage.py', but display every query to the console
# to keep the coder depressed
#
# Mario Orlandi, adapted from http://gist.github.com/118990
#

sqlparse = None
try:
    import sqlparse
except ImportError:
    sqlparse = None


class PrintQueryWrapper(util.CursorDebugWrapper):
    def execute(self, sql, params=()):
        try:
            return self.cursor.execute(sql, params)
        finally:
            raw_sql = self.db.ops.last_executed_query(self.cursor, sql, params)
            print '\x1b[1;;43;30m',  # turn highlight on
            if sqlparse:
                print sqlparse.format(raw_sql, reindent=True),
            else:
                print raw_sql,
            print '\x1b[0m'  # turn highlight off
            print ''


if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")
    from django.core.management import execute_from_command_line

    try:
        util.CursorDebugWrapper = PrintQueryWrapper
    except:
        pass

    execute_from_command_line(sys.argv)

Previous implementation

Adapted from django-extensions to print queries during 'runserver';
may be used when tracing code via pdb.

Usage: call setup_print_queries() once after DJANGO_SETTINGS_MODULE has been set
(typically in manage.py; see also: http://eldarion.com/blog/2013/02/14/entry-point-hook-django-projects/)
 
from django.db.backends import util
from django.conf import settings


# Adapted by Mario Orlandi from http://gist.github.com/118990
sqlparse = None
try:
    import sqlparse
except ImportError:
    sqlparse = None


class PrintQueryWrapper(util.CursorDebugWrapper):
    def execute(self, sql, params=()):
        try:
            return self.cursor.execute(sql, params)
        finally:
            raw_sql = self.db.ops.last_executed_query(self.cursor, sql, params)
            print '\x1b[1;;43;30m',  # turn highlight on
            if sqlparse:
                print sqlparse.format(raw_sql, reindent=True),
            else:
                print raw_sql,
            print '\x1b[0m'  # turn highlight off


def setup_print_queries():
    if settings.DEBUG and settings.PRINT_QUERIES:
        util.CursorDebugWrapper = PrintQueryWrapper
by

Count queries with a Django middleware

file “development.py”:

MIDDLEWARE_CLASSES = list(MIDDLEWARE_CLASSES) + ['djangobase.middleware.QueryCountDebugMiddleware',]

file “middleware.py”:

from django.db import connection

##########################################################################################################
# Adapted from: http://dabapps.com/blog/logging-sql-queries-django-13/

class QueryCountDebugMiddleware(object):
    """
    This middleware will log the number of queries run and the total time taken for each request (with a
    status code of 200). It does not currently support multi-db setups.
    """
    def process_response(self, request, response):
        if request.path_info.find('media') > 0:
            return response
        if response.status_code == 200:
            total_time = 0

            try:
                if len(connection.queries) == 1:
                    if connection.queries[0]['raw_sql'].startswith('SELECT "django_session"'):
                        return response
            except:
                pass

            for query in connection.queries:
                query_time = float(query.get('time'))
                if query_time is None:
                    # django-debug-toolbar monkeypatches the connection
                    # cursor wrapper and adds extra information in each
                    # item in connection.queries. The query time is stored
                    # under the key "duration" rather than "time" and is
                    # in milliseconds, not seconds.
                    query_time = query.get('duration', 0) / 1000

                print '%s[%6.4f] %s' % ('\x1b[1;33;40m', query_time, query['sql'])
                total_time += float(query_time)

            print '\x1b[1;;43;30m==> %s queries run, total %s seconds    \x1b[0m' % (len(connection.queries), total_time)

        return response
by

Django debugging 

from: http://stackoverflow.com/questions/1118183/how-to-debug-in-django-the-good-way

- import pdb; pdb.set_trace() 
- ipdb.set_trace() (requires iphyton)
- return HttpResponse({variable to inspect})
- raise Exception({variable to inspect})

- Werkzeug's interactive debugger: > manage runserver_plus, then 'raise' (requires django-extensions)

- {{ template_var|pdb }} ... enter pdb session to inspect element.
Requires this template tag:

@register.filter 
def pdb(element):
    """ Usage: {{ template_var|pdb }}
        then inspect 'element' from pdb
    """
    import pdb; pdb.set_trace()
    return element

- django-viewtools for debugging views interactively using pdb
by

send django queries to OutputDebugString (Win32) 

Modify django/db/backends/util.py as follows:

import win32api

class CursorDebugWrapper(object):
    def __init__(self, cursor, db):
        self.cursor = cursor
        self.db = db # Instance of a BaseDatabaseWrapper subclass

    def debug_trace(self,category,message):
        win32api.OutputDebugString('|django              |%s|%s\n' % (category,message))

    def trace_entry (self, sql, elapsed):
        self.debug_trace('Q',sql)
        if elapsed >= 0.01:
            self.debug_trace(' ','elapsed: %.3f' % elapsed)

    def execute(self, sql, params=()):
        start = time()
        try:
            return self.cursor.execute(sql, params)
        finally:
            stop = time()
            sql = self.db.ops.last_executed_query(self.cursor, sql, params)
            self.db.queries.append({
                'sql': sql,
                'time': "%.3f" % (stop - start),
            })
            self.trace_entry(sql, stop - start) 

    def executemany(self, sql, param_list):
        start = time()
        try:
            return self.cursor.executemany(sql, param_list)
        finally:
            stop = time()
            self.db.queries.append({
                'sql': '%s times: %s' % (len(param_list), sql),
                'time': "%.3f" % (stop - start),
            })
            self.trace_entry(sql, stop - start)