Ticket #12012: 12012-r11603.diff

django/__init__.py

@@ +1 @@
+from django.utils import log
+
 VERSION = (1, 2, 0, 'alpha', 0)
 
 def get_version():

django/conf/__init__.py

@@ -108 +108 @@
             os.environ['TZ'] = self.TIME_ZONE
             time.tzset()
 
+        if getattr(self, 'LOGGING', None):
+            from django.utils import log
+            log.configure_from_dict(self.LOGGING)
+
     def get_all_members(self):
         return dir(self)
 

django/core/management/commands/runserver.py

@@ -9 +9 @@
             help='Tells Django to NOT use the auto-reloader.'),
         make_option('--adminmedia', dest='admin_media_path', default='',
             help='Specifies the directory from which to serve admin media.'),
+        make_option('--loglevel', dest='log_levels', action='append',
+            help='Set the minimum log level to be displayed at the console'),
     )
     help = "Starts a lightweight Web server for development."
     args = '[optional port number, or ipaddr:port]'
@@ -39 +41 @@
         use_reloader = options.get('use_reloader', True)
         admin_media_path = options.get('admin_media_path', '')
         shutdown_message = options.get('shutdown_message', '')
+        log_levels = options.get('log_levels', [])
         quit_command = (sys.platform == 'win32') and 'CTRL-BREAK' or 'CONTROL-C'
 
+        if log_levels:
+            from django.utils.log import logger as django_logger
+            import logging
+            django_logger.addHandler(logging.StreamHandler())
+            for log_level in log_levels:
+                try:
+                    log_name, level = log_level.split(':')
+                except ValueError:
+                    raise CommandError("Invalid log level specified")
+                if level.isdigit():
+                    level = int(level)
+                else:
+                    level = getattr(logging, level.upper(), None)
+                    if level is None:
+                        raise CommandError("Invalid log level: %s" % level)
+                logging.getLogger(log_name).setLevel(level)
+
         def inner_run():
             from django.conf import settings
             from django.utils import translation
+
             print "Validating models..."
             self.validate(display_num_errors=True)
             print "\nDjango version %s, using settings %r" % (django.get_version(), settings.SETTINGS_MODULE)

django/db/backends/__init__.py

@@ -81 +81 @@
         cursor = self._cursor()
         if settings.DEBUG:
             return self.make_debug_cursor(cursor)
-        return cursor
+        return self.make_logging_cursor(cursor)
 
     def make_debug_cursor(self, cursor):
         return util.CursorDebugWrapper(cursor, self)
 
+    def make_logging_cursor(self, cursor):
+        return util.CursorLoggingWrapper(cursor, self)
+
 class BaseDatabaseFeatures(object):
     allows_group_by_pk = False
     # True if django.db.backend.utils.typecast_timestamp is used on values

django/db/backends/util.py

@@ -1 +1 @@
 import datetime
 from time import time
-
 from django.utils.hashcompat import md5_constructor
+import logging
+logger = logging.getLogger('django.db.sql')
 
 try:
     import decimal
 except ImportError:
     from django.utils import _decimal as decimal    # for Python 2.3
 
-class CursorDebugWrapper(object):
+class CursorWrapper(object):
+    def __init__(self, cursor, db):
+        self.cursor = cursor
+        self.db = db # Instance of a BaseDatabaseWrapper subclass
+
+    def __getattr__(self, attr):
+        if attr in self.__dict__:
+            return self.__dict__[attr]
+        else:
+            return getattr(self.cursor, attr)
+
+    def __iter__(self):
+        return iter(self.cursor)
+
+class CursorLoggingWrapper(CursorWrapper):
+    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)
+            logger.info('%.3fs:\t%s' % (stop - start, sql))
+
+    def executemany(self, sql, param_list):
+        start = time()
+        try:
+            return self.cursor.executemany(sql, param_list)
+        finally:
+            stop = time()
+            logger.info('%.3fs:\t%s' % (stop - start, sql))
+
+class CursorDebugWrapper(CursorWrapper):
     def __init__(self, cursor, db):
         self.cursor = cursor
         self.db = db # Instance of a BaseDatabaseWrapper subclass
@@ -24 +57 @@
                 'sql': sql,
                 'time': "%.3f" % (stop - start),
             })
+            logger.info('%.3fs:\t%s' % (stop - start, sql))
 
     def executemany(self, sql, param_list):
         start = time()
@@ -35 +69 @@
                 'sql': '%s times: %s' % (len(param_list), sql),
                 'time': "%.3f" % (stop - start),
             })
-
-    def __getattr__(self, attr):
-        if attr in self.__dict__:
-            return self.__dict__[attr]
-        else:
-            return getattr(self.cursor, attr)
-
-    def __iter__(self):
-        return iter(self.cursor)
+            logger.info('%.3fs:\t%s' % (stop - start, sql))
 
 ###############################################
 # Converters from database (string) to Python #

new file django/utils/log.py

@@ +1 @@
+from django.utils.importlib import import_module
+from django.core.exceptions import ImproperlyConfigured
+import logging
+
+class NullHandler(logging.Handler): 
+    def emit(self, record): 
+        pass
+
+logger = logging.getLogger('django')
+logger.setLevel(logging.INFO)
+if len(logger.handlers) == 0:
+    logger.addHandler(NullHandler())
+logger.propagate = False
+
+def configure_from_dict(configuration):
+    "Configure loggers using a settings.LOGGING style dictionary"
+    for logger_label, config in configuration.items():
+        logger = logging.getLogger(logger_label)
+        level = config.pop('level', None)
+        if level is not None:
+            if level.isdigit():
+                level_int = int(level)
+            else:
+                level_int = getattr(logging, level.upper(), None)
+                if level_int is None:
+                    raise ImproperlyConfigured, \
+                        '"%s" is not a valid logging level' % level
+            logger.setLevel(level_int)
+        handler = config.pop('handler', None)
+        if handler is not None:
+            klass = handler_from_string(handler)
+            logger.addHandler(klass(**config))
+
+def handler_from_string(string):
+    # Could refactor with django.core.handlers.base.BaseHandler.load_middleware
+    try:
+        dot = string.rindex('.')
+    except ValueError:
+        raise ImproperlyConfigured, '%s isn\'t a handler module' % string
+    module, classname = string[:dot], string[dot+1:]
+    try:
+        mod = import_module(module)
+    except ImportError, e:
+        raise ImproperlyConfigured, 'Error importing handler %s: "%s"' % (module, e)
+    try:
+        klass = getattr(mod, classname)
+    except AttributeError:
+        raise ImproperlyConfigured, 'Module "%s" does not define a "%s" class' % (module, classname)
+    return klass