11

Is there a simple way to disable the logging of an exception stack trace in Python 3, either in a Handler or Formatter?

I need the stack trace in another Handler, so setting exc_info=False, in the call to the Logger is not an option. Is there a simpler way than just defining my own Formatter?

Martijn Pieters
  • 1,048,767
  • 296
  • 4,058
  • 3,343
H.T.
  • 141
  • 1
  • 5

3 Answers3

13

The easiest option to disable per handler traceback output is to add a custom logging.Filter subclass that alters the record object (rather than filter out records).

The filter simply has to set exc_info on records to None:

class TracebackInfoFilter(logging.Filter):
    """Clear or restore the exception on log records"""
    def __init__(self, clear=True):
        self.clear = clear
    def filter(self, record):
        if self.clear:
            record._exc_info_hidden, record.exc_info = record.exc_info, None
            # clear the exception traceback text cache, if created.
            record.exc_text = None
        elif hasattr(record, "_exc_info_hidden"):
            record.exc_info = record._exc_info_hidden
            del record._exc_info_hidden
        return True

and add that filter on your handler:

# do not display tracebacks in messages handled with this handler,
# by setting the traceback cache to a non-empty string:
handler_with_no_tracebacks.addFilter(TracebackInfoFilter())

However, handlers do not copy log records, and any other handler that is passed the same log record later on will also ignore formatting the traceback. So you also need to configure any other handlers to restore the information again:

for handler in logger.handlers:
    if not any(isinstance(f, TracebackInfoFilter) for f in handler.filters):
        handler.addFilter(TracebackInfoFilter(clear=False))

If anyone wanted to disable all traceback outputs, everywhere, then perhaps adding a custom filter to all handlers or loggers becomes tedious. In that case another option is to register a custom record factory with the logging.setLogRecordFactory() function; just set the exc_info attribute on records to None, unconditionally:

record_factory = logging.getLogRecordFactory()

def clear_exc_text(*args, **kwargs):
    record = record_factory(*args, **kwargs)
    record.exc_info = None
    return record

logging.setLogRecordFactory(clear_exc_text)

Note that the default factory is just the logging.LogRecord class, but the above function does its best to work with any already-set custom factory.

Of course, you can also create your own Handler subclass where the Handler.handle() sets and clears the exc_info attribute:

class NoTracebackHandler(logging.Handler):
    def handle(self, record):
        info, cache = record.exc_info, record.exc_text
        record.exc_info, record.exc_text = None, None
        try:
            super().handle(record)
        finally:
            record.exc_info = info
            record.exc_text = cache
Martijn Pieters
  • 1,048,767
  • 296
  • 4,058
  • 3,343
  • I have used two handlers, for console and file. I dont want stack trace on console , I used above approach but stack trace is getting printed on both console and file. Below is the code """""""fileHandler = logging.FileHandler("{0}/{1}".format(logPath, fileName)) fileHandler.setFormatter(logFormatter) Logger.addHandler(fileHandler) consoleHandler = logging.StreamHandler() consoleHandler.setFormatter(logFormatter) consoleHandler.addFilter(SetTracebackCacheFilter('')) Logger.addHandler(consoleHandler)"""""""" – charanReddy Jul 25 '19 at 20:19
  • @ragireddysricharanreddy: ick, I see what is going wrong; an empty string still is seen as an empty cache. I'll rework this answer. – Martijn Pieters Jul 27 '19 at 13:34
  • I resolved it....we need to add record.exc_info = False in filter function – charanReddy Jul 27 '19 at 13:36
  • @ragireddysricharanreddy: I set it to `None`. Take into account that this will affect *other* handlers if they are run later on. – Martijn Pieters Jul 27 '19 at 13:43
  • Nice solution but a word of caution (which is not the fault of @Martijn Pieters). If your handler is behind a QueueHandler you must override the QueueHandler.prepare() function so that the only thing it does is `return record`. Otherwise it is modifying the record so that this solution doesn't work. – Martin Riddar May 10 '20 at 07:24
2

It can be done even easier than Digoya's answer:

class NoTracebackFormatter(logging.Formatter):
    def formatException(self, ei):
        return ""
    def formatStack(self, stack_info):
        return ""

(Tested on Python 3.9)

Jonathon Reinhart
  • 132,704
  • 33
  • 254
  • 328
0

Late response but it might me useful for somebody else. You don't need to bother with Handler nor Filter. You just need to inherit your own Formatter and skip the part where you format exception. Here is a snippet I use:

class EnhancedFormatter(logging.Formatter):
    def __init__(self, fmt=None, datefmt=None, style='%', validate=True, skip_traceback=False):
        self.skip_traceback = skip_traceback
        super(EnhancedFormatter, self).__init__(fmt, datefmt, style, validate)

    def format(self, record) -> str:
        record.message = record.getMessage()
        if self.usesTime():
            record.asctime = self.formatTime(record, self.datefmt)
        s = self.formatMessage(record)
        if not self.skip_traceback: # check here do you need to format traceback
            if record.exc_info:
                if not record.exc_text:
                    record.exc_text = self.formatException(record.exc_info)
            if record.exc_text:
                if s[-1:] != "\n":
                    s = s + "\n"
                s = s + record.exc_text
            if record.stack_info:
                if s[-1:] != "\n":
                    s = s + "\n"
                s = s + self.formatStack(record.stack_info)
        return s

Just set skip_traceback argument while instantiating the formatter class and later use it to determine do you need to format traceback or not.

Digoya
  • 121
  • 3