diff --git a/django/__init__.py b/django/__init__.py index 2b87a7e..b92c1f4 100644 --- a/django/__init__.py +++ b/django/__init__.py @@ -1,3 +1,5 @@ +from django.utils import log + VERSION = (1, 2, 0, 'alpha', 0) def get_version(): diff --git a/django/conf/__init__.py b/django/conf/__init__.py index 7bc7ae9..793c721 100644 --- a/django/conf/__init__.py +++ b/django/conf/__init__.py @@ -108,6 +108,10 @@ class Settings(object): 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) diff --git a/django/core/management/commands/runserver.py b/django/core/management/commands/runserver.py index fc2c694..78798f1 100644 --- a/django/core/management/commands/runserver.py +++ b/django/core/management/commands/runserver.py @@ -9,6 +9,8 @@ class Command(BaseCommand): 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,11 +41,30 @@ class Command(BaseCommand): 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) diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py index 9a1fe30..a183941 100644 --- a/django/db/backends/__init__.py +++ b/django/db/backends/__init__.py @@ -81,11 +81,14 @@ class BaseDatabaseWrapper(local): 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 diff --git a/django/db/backends/util.py b/django/db/backends/util.py index f9c07a9..ca0043a 100644 --- a/django/db/backends/util.py +++ b/django/db/backends/util.py @@ -1,14 +1,47 @@ 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,6 +57,7 @@ class CursorDebugWrapper(object): 'sql': sql, 'time': "%.3f" % (stop - start), }) + logger.info('%.3fs:\t%s' % (stop - start, sql)) def executemany(self, sql, param_list): start = time() @@ -35,15 +69,7 @@ class CursorDebugWrapper(object): '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 # diff --git a/django/utils/log.py b/django/utils/log.py new file mode 100644 index 0000000..21fd0aa --- /dev/null +++ b/django/utils/log.py @@ -0,0 +1,49 @@ +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