loggers: Log runtime errors through the logging framework

This ensures that the exceptions are always included in the debug log,
and moves the logic that determines whether to print exception output
into the loggers logic where it belongs.

flent/__init__.py

@@ -40,6 +40,10 @@ def run_flent(gui=False):
         locale.setlocale(locale.LC_ALL, '')
         from flent import batch
         from flent.settings import load
+        from flent.loggers import setup_console, get_logger
+
+        setup_console()
+        logger = get_logger(__name__)
 
         try:
             signal.signal(signal.SIGTERM, handle_sigterm)
@@ -52,15 +56,8 @@ def run_flent(gui=False):
                 b.run()
 
         except RuntimeError as e:
-            try:
-                if not settings.DEBUG_ERROR:
-                    sys.stderr.write("Fatal error: %s\n" % str(e))
-                    return 1
-                else:
-                    raise
-            except NameError:
-                sys.stderr.write("Fatal error: %s\n" % str(e))
-                return 1
+            logger.exception(str(e))
+
     except KeyboardInterrupt:
         try:
             b.kill()

flent/loggers.py

@@ -24,7 +24,10 @@
 import logging
 import sys
 
-from logging import StreamHandler, FileHandler
+from logging import StreamHandler, FileHandler, Formatter
+
+err_handler = out_handler = None
+
 
 class MaxFilter(object):
 
@@ -37,26 +40,45 @@ def filter(self, record):
         return 1
 
 
+class LogFormatter(Formatter):
+    def __init__(self, *args, **kwargs):
+        self.format_exceptions = True
+        super(LogFormatter, self).__init__(*args, **kwargs)
+
+    def formatException(self, ei):
+        if self.format_exceptions:
+            return super(LogFormatter, self).formatException(ei)
+        return ""
+
+    def disable_exceptions(self):
+        self.format_exceptions = False
+
+
 def get_logger(name):
     return logging.getLogger(name)
 
 
 def setup_console():
+    global err_handler, out_handler
+
+    if err_handler is not None:
+        return
+
     logger = logging.getLogger()
 
-    err = StreamHandler(sys.stderr)
-    err.setLevel(logging.WARNING)
-    fmt = logging.Formatter(fmt="%(levelname)s: %(message)s")
-    err.setFormatter(fmt)
-    logger.addHandler(err)
+    err_handler = StreamHandler(sys.stderr)
+    err_handler.setLevel(logging.WARNING)
+    fmt = LogFormatter(fmt="%(levelname)s: %(message)s")
+    err_handler.setFormatter(fmt)
+    logger.addHandler(err_handler)
 
-    out = StreamHandler(sys.stdout)
-    out.setLevel(logging.INFO)
-    fmt = logging.Formatter(fmt="%(message)s")
-    out.setFormatter(fmt)
+    out_handler = StreamHandler(sys.stdout)
+    out_handler.setLevel(logging.INFO)
+    fmt = LogFormatter(fmt="%(message)s")
+    out_handler.setFormatter(fmt)
     filt = MaxFilter(logging.INFO)
-    out.addFilter(filt)
-    logger.addHandler(out)
+    out_handler.addFilter(filt)
+    logger.addHandler(out_handler)
 
     logger.setLevel(logging.INFO)
 
@@ -72,9 +94,14 @@ def setup_file(filename):
 
     handler = FileHandler(filename, encoding='utf-8')
     handler.setLevel(logging.DEBUG)
-    fmt = logging.Formatter(
+    fmt = LogFormatter(
         fmt="%(asctime)s [%(name)s] %(levelname)s: %(message)s")
     handler.setFormatter(fmt)
     logger.addHandler(handler)
 
     logger.setLevel(logging.DEBUG)
+
+
+def disable_exceptions():
+    if err_handler is not None:
+        err_handler.formatter.disable_exceptions()

flent/settings.py

@@ -674,7 +674,8 @@ def load(argv):
     settings.process_args()
     settings.update_implications()
 
-    loggers.setup_console()
+    if not settings.DEBUG_ERROR:
+        loggers.disable_exceptions()
 
     if settings.SCALE_DATA:
         scale_data = []