Basic implementation of a swtichable logging system

Author: mitsuhiko

CHANGES

@@ -17,6 +17,9 @@ Release date to be announced, codename to be selected
   deprecated for :func:`flask.send_file` because it was unreliable.
   Pass filenames instead or attach your own etags and provide a
   proper mimetype by hand.
+- Added support for Logbook and started the slow deprecation process
+  for logging.
+- Removed `flask.Flask.debug_log_format` attribute.
 
 Version 0.6.1
 -------------

flask/app.py

@@ -33,6 +33,7 @@
 from .templating import _DispatchingJinjaLoader, \
     _default_template_ctx_processor
 from .signals import request_started, request_finished, got_request_exception
+from .logging import init_logging_system, create_logger
 
 # a lock used for logger initialization
 _logger_lock = Lock()
@@ -171,15 +172,6 @@ class Flask(_PackageBoundObject):
     #: .. versionadded:: 0.4
     logger_name = ConfigAttribute('LOGGER_NAME')
 
-    #: the name of the logging system that is configured by default.  The
-    #: default is ``'logging'`` but it can be set to ``'logbook'`` as well.
-    #: The default will change to ``'logbook'`` at one point and later the
-    #: ``'logging'`` support will eventually disappear together with this
-    #: setting.  Check the :ref:`log-transition` for more information.
-    #:
-    #: .. versionadded:: 0.7
-    logging_system = ConfigAttribute('LOGGING_SYSTEM')
-
     #: the logbook setup that should be in use.  This is only used in case
     #: the `LOGGING_SYSTEM` is ``'logbook'``.  It can point to any
     #: :class:`logbook.Processor`, :class:`logbook.Handler` or
@@ -188,18 +180,6 @@ class Flask(_PackageBoundObject):
     #: also subclass :class:`Flask` or use the signals to push and pop.
     logbook_setup = None
 
-    #: The logging format used for the debug logger.  This is only used when
-    #: the application is in debug mode, otherwise the attached logging
-    #: handler does the formatting.
-    #:
-    #: .. versionadded:: 0.3
-    debug_log_format = (
-        '-' * 80 + '\n' +
-        '%(levelname)s in %(module)s [%(pathname)s:%(lineno)d]:\n' +
-        '%(message)s\n' +
-        '-' * 80
-    )
-
     #: Options that are passed directly to the Jinja2 environment.
     jinja_options = ImmutableDict(
         extensions=['jinja2.ext.autoescape', 'jinja2.ext.with_']
@@ -215,11 +195,10 @@ class Flask(_PackageBoundObject):
         'USE_X_SENDFILE':                       False,
         'LOGGER_NAME':                          None,
         'SERVER_NAME':                          None,
-        'MAX_CONTENT_LENGTH':                   None,
-        'LOGGING_SYSTEM':                       'logging'
+        'MAX_CONTENT_LENGTH':                   None
     })
 
-    def __init__(self, import_name, static_path=None, use_logbook=None):
+    def __init__(self, import_name, static_path=None, logging_system=None):
         _PackageBoundObject.__init__(self, import_name)
         if static_path is not None:
             self.static_path = static_path
@@ -325,6 +304,12 @@ def __init__(self, import_name, static_path=None, use_logbook=None):
         self.jinja_env = self.create_jinja_environment()
         self.init_jinja_globals()
 
+        # initialize logging
+        if logging_system is None:
+            logging_system = 'logging'
+        self.logging_system = logging_system
+        init_logging_system(self)
+
     @property
     def logger(self):
         """A :class:`logging.Logger` object for this application.  The
@@ -348,7 +333,6 @@ def logger(self):
         with _logger_lock:
             if self._logger and self._logger.name == self.logger_name:
                 return self._logger
-            from flask.logging import create_logger
             self._logger = rv = create_logger(self)
             return rv
 

flask/logging.py

@@ -3,7 +3,14 @@
     flask.logging
     ~~~~~~~~~~~~~
 
-    Implements the logging support for Flask.
+    Implements the logging support for Flask.  This is not supposed to be a
+    abstraction layer above multiple logging systems, it mainly exists because
+    Flask started out using logging and is currently in the process to switch
+    to Logbook.  This module will become mostly useless once we drop support
+    for the stdlib's logging.
+
+    In some other parts of Flask there are explicit hardcoded checks that
+    opt-in features in case Logbook is present.
 
     :copyright: (c) 2010 by Armin Ronacher.
     :license: BSD, see LICENSE for more details.
@@ -13,21 +20,41 @@
 
 
 def create_logger(app):
+    """Creates a new logger for the application.  This is mainly needed
+    because Flask supports dynamic logger name changes.  Once we drop
+    support for logging we can remove this as well because it is easily
+    possible to reflect the channel name from another value in logbook
+    """
+    return logging_systems[app.logging_system][1](app)
+
+
+def init_logging_system(app):
     """Initializes the logging system for this app."""
-    return logging_systems[app.logging_system](app)
+    return logging_systems[app.logging_system][0](app)
 
 
-def init_logbook(app):
+def create_logbook_logger(app):
     """Initializes the logbook default config for the application."""
-    try:
-        from logbook import Logger
-    except ImportError:
-        raise RuntimeError('Logbook is not installed but required for '
-                           'the logbook logging backend.')
+    from logbook import Logger
     return Logger(app.logger_name)
 
 
-def init_logging(app):
+def init_logbook(app):
+    """Stuffs a default logging setup on the application object in case
+    the attribute was not set so far.
+    """
+    if app.logbook_setup is None:
+        from logbook import StderrHandler
+        app.logbook_setup = StderrHandler(format_string=(
+            '-' * 80 + '\n' +
+            '{record.level_name} in {record.module} '
+                '[{record.filename}:{record.lineno}]:\n' +
+            '{record.message}\n' +
+            '-' * 80
+        ))
+
+
+def create_logging_logger(app):
     """Creates a logger for the given application.  This logger works
     similar to a regular Python logger but changes the effective logging
     level based on the application's debug flag.  Furthermore this
@@ -46,7 +73,12 @@ def emit(x, record):
 
     handler = DebugHandler()
     handler.setLevel(DEBUG)
-    handler.setFormatter(Formatter(app.debug_log_format))
+    handler.setFormatter(Formatter(
+        '-' * 80 + '\n' +
+        '%(levelname)s in %(module)s [%(pathname)s:%(lineno)d]:\n' +
+        '%(message)s\n' +
+        '-' * 80
+    ))
     logger = getLogger(app.logger_name)
     # just in case that was not a new logger, get rid of all the handlers
     # already attached to it.
@@ -56,7 +88,23 @@ def emit(x, record):
     return logger
 
 
+def create_dummy_logger(app):
+    """Creates a dummy logger."""
+    return _DummyLogger(app.logger_name)
+
+
+class _DummyLogger(object):
+    """Not a very helpful logger."""
+    def __init__(self, name, level=0):
+        self.name = name
+        self.level = level
+    debug = info = warn = warning = notice = error = exception = \
+        critical = log = lambda *a, **kw: None
+
+
+_dummy = lambda x: None
 logging_systems = {
-    'logbook':      init_logbook,
-    'logging':      init_logging
+    'logbook':      (init_logbook, create_logbook_logger),
+    'logging':      (_dummy, create_logging_logger),
+    'none':         (_dummy, create_dummy_logger)
 }

tests/flask_tests.py

@@ -950,8 +950,8 @@ def test_logger_cache(self):
         app.logger_name = __name__ + '/test_logger_cache'
         assert app.logger is not logger1
 
-    def test_debug_log(self):
-        app = flask.Flask(__name__)
+    def perform_debug_log_test(self, logging_system):
+        app = flask.Flask(__name__, logging_system=logging_system)
         app.debug = True
 
         @app.route('/')
@@ -981,6 +981,12 @@ def exc():
             else:
                 assert False, 'debug log ate the exception'
 
+    def test_logging_debug_log(self):
+        self.perform_debug_log_test('logging')
+
+    def test_logbook_debug_log(self):
+        self.perform_debug_log_test('logbook')
+
     def test_exception_logging(self):
         out = StringIO()
         app = flask.Flask(__name__)