Fully disable python logging

Question

In my code I use logging.info(... and before that I configure with logging.basicConfig(filename=.... Is it possible to keep the logging lines in the code without them doing anything?

Answer 1

You can use:

logging.disable(logging.CRITICAL)

to disable all logging calls which are at level CRITICAL or below. Effectively this disables all logging calls.

You can enable the logging for all loggers again (at their own logging levels) by doing:

logging.disable(logging.NOTSET)

Answer 2

Logging has the following structure:

• loggers are arranged according to a namespace hierarchy with dot separators;
• each logger has a level (logging.WARNING by default for the root logger and logging.NOTSET by default for non-root loggers) and an effective level (the effective level of the parent logger for non-root loggers with a level logging.NOTSET and the level of the logger otherwise);
• each logger has a list of filters;
• each logger has a list of handlers;
• each handler has a level (logging.NOTSET by default);
• each handler has a list of filters.

Logging has the following process (represented by a flowchart):

Therefore to disable a particular logger you can adopt one of the following strategies:

1. Set the level of the logger to logging.CRITICAL + 1.

   • Using the main API:

     import logging
     
     logger = logging.getLogger("foo")
     logger.setLevel(logging.CRITICAL + 1)
     

   • Using the config API:

     import logging.config
     
     logging.config.dictConfig({
         "version": 1,
         "loggers": {
             "foo": {
                 "level": logging.CRITICAL + 1
             }
         }
     })
     

2. Add a filter lambda record: False to the logger.

   • Using the main API:

     import logging
     
     logger = logging.getLogger("foo")
     logger.addFilter(lambda record: False)
     

   • Using the config API:

     import logging.config
     
     logging.config.dictConfig({
         "version": 1,
         "filters": {
             "all": {
                 "()": lambda: (lambda record: False)
             }
         },
         "loggers": {
             "foo": {
                 "filters": ["all"]
             }
         }
     })
     

3. Remove the existing handlers of the logger, add a handler logging.NullHandler() to the logger (to prevent events from being handled by the handler logging.lastResort which is a logging.StreamHandler using the current stream sys.stderr and a level logging.WARNING) and set the attribute propagate of the logger to False (to prevent events from being handled by the handlers of the ancestor loggers of the logger).

   • Using the main API:

     import logging
     
     logger = logging.getLogger("foo")
     for handler in logger.handlers.copy():
         try:
             logger.removeHandler(handler)
         except ValueError:  # in case another thread has already removed it
             pass
     logger.addHandler(logging.NullHandler())
     logger.propagate = False
     

   • Using the config API:

     import logging.config
     
     logging.config.dictConfig({
         "version": 1,
         "handlers": {
             "null": {
                 "class": "logging.NullHandler"
             }
         },
         "loggers": {
             "foo": {
                 "handlers": ["null"],
                 "propagate": False
             }
         }
     })
     

Warning. — Contrary to strategies 1 and 2 which only prevent events logged by the logger from being emitted by the handlers of the logger and its ancestor loggers, strategy 3 also prevents events logged by the descendant loggers of the logger (e.g. logging.getLogger("foo.bar")) to be emitted by the handlers of the logger and its ancestor loggers.

Note. — Setting the attribute disabled of the logger to True is not yet another strategy, as it is not part of the public API (cf. https://github.com/python/cpython/issues/80499):

import logging

logger = logging.getLogger("foo")
logger.disabled = True  # DO NOT DO THIS

Answer 3

EDIT: it seems that disabled is not supposed to be meant for public use. Look at Maggyero's answer for alternative solutions.

Just disable the log handler and it won't write to anything anymore.

logging.getLogger().disabled = True

Do note that every logger can have handlers so there might be more.

Answer 4

If you want full disable logs first should in logging.basicConfig() set levevl equal logging.NOTSET because is zero level and then logging.getLogger().disabled set True or False. https://docs.python.org/2/library/logging.html

Example for full disable:

import logging

if __name__ == '__main__':
     logging.disable(logging.NOTSET)

     logging.basicConfig(
     format="%(levelname) -10s %(asctime)s %(filename)s:%(lineno)s  %(message)s",
     level=logging.NOTSET)

     logging.getLogger().disabled = True  # True, False

     logging.critical("Critical")
     logging.error("Error")
     logging.warning("Warning")
     logging.info("Info")
     logging.debug("Debug")