How to disable logging on the standard error stream in Python

Question

How to disable logging on the standard error stream in Python  This does not work  import logging  logger   logging getLogger   logger removeHandler sys stderr  logger warning  foobar      emits  foobar  on sys stderr

User · Answer

subclass the handler you want to be able to disable temporarily:

class ToggledHandler(logging.StreamHandler):
"""A handler one can turn on and off"""

def __init__(self, args, kwargs):
    super(ToggledHandler, self).__init__(*args, **kwargs)
    self.enabled = True  # enabled by default

def enable(self):
    """enables"""
    self.enabled = True

def disable(self):
    """disables"""
    self.enabled = False

def emit(self, record):
    """emits, if enabled"""
    if self.enabled:
        # this is taken from the super's emit, implement your own
        try:
            msg = self.format(record)
            stream = self.stream
            stream.write(msg)
            stream.write(self.terminator)
            self.flush()
        except Exception:
            self.handleError(record)

finding the handler by name is quite easy:

_handler = [x for x in logging.getLogger('').handlers if x.name == your_handler_name]
if len(_handler) == 1:
    _handler = _handler[0]
else:
    raise Exception('Expected one handler but found {}'.format(len(_handler))

once found:

_handler.disable()
doStuff()
_handler.enable()

User · Answer

I use   logger   logging getLogger   logger disabled   True     whatever you want     logger disabled   False

User · Answer

To fully disable logging   logging disable sys maxint    Python 2  logging disable sys maxsize    Python 3   To enable logging   logging disable logging NOTSET      Other answers provide work arounds which don t fully solve the problem  such as  logging getLogger   disabled   True   and  for some n greater than 50   logging disable n    The problem with the first solution is that it only works for the root logger  Other loggers created using  say  logging getLogger   name    are not disabled by this method   The second solution does affect all logs  But it limits output to levels above that given  so one could override it by logging with a level greater than 50    That can be prevented by  logging disable sys maxint    which as far as I can tell  after reviewing the source  is the only way to fully disable logging

User · Answer

You can change the level of debug mode for specific handler instead of completely disable it  So if you have a case you want to stop the debug mode for console only but you still need to keep the other levels like the Error  you can do this like the following   create logger logger   logging getLogger   name     def enableConsoleDebug  debug   False        Set level to logging DEBUG to see CRITICAL  ERROR  WARNING  INFO and DEBUG statements      Set level to logging ERROR to see the CRITICAL  amp  ERROR statements only     logger setLevel logging DEBUG       debugLevel   logging ERROR     if debug          debugLevel   logging DEBUG      for handler in logger handlers          if type handler  is logging StreamHandler              handler setLevel  debugLevel

User · Answer

import logging  log file    test log  info format      asctime s -   levelname s -   message s  logging config dictConfig        version   1       disable existing loggers   False       formatters              info format                  format   info format                        handlers              console                  level    INFO                class    logging StreamHandler                formatter    info format                      info log file                  class    logging handlers RotatingFileHandler                level    INFO                filename   log file               formatter    info format                        loggers                                handlers                      console                    info log file                              level    INFO                       class A       def   init   self           logging info  object created of class A            self logger   logging getLogger           self console handler   None      def say self  word           logging info  A object says      format word        def disable console log self           if self console handler is not None                Console log has already been disabled             return          for handler in self logger handlers              if type handler  is logging StreamHandler                  self console handler   handler                 self logger removeHandler handler       def enable console log self           if self console handler is None                Console log has already been enabled             return          self logger addHandler self console handler          self console handler   None   if   name         main         a   A       a say  111       a disable console log       a say  222       a enable console log       a say  333     Console output   2018-09-15 15 22 23 354 - INFO - object created of class A 2018-09-15 15 22 23 356 - INFO - A object says  111 2018-09-15 15 22 23 358 - INFO - A object says  333   test log file content   2018-09-15 15 22 23 354 - INFO - object created of class A 2018-09-15 15 22 23 356 - INFO - A object says  111 2018-09-15 15 22 23 357 - INFO - A object says  222 2018-09-15 15 22 23 358 - INFO - A object says  333

User · Answer

No need to divert stdout  Here is better way to do it   import logging class MyLogHandler logging Handler       def emit self  record           pass  logging getLogger   addHandler MyLogHandler      An even simpler way is   logging getLogger   setLevel 100

User · Answer

You could also   handlers   app logger handlers   detach console handler app logger handlers        attach app logger handlers   handlers

User · Answer

Found an elegant solution using decorators  which addresses the following problem  what if you are writing a module with several functions  each of them with several debugging messages  and you want to disable logging in all functions but the one you are currently focusing on   You can do it using decorators   import logging  sys logger   logging getLogger   logging basicConfig stream sys stderr  level logging DEBUG    def disable debug messages func       def wrapper  args    kwargs           prev state   logger disabled         logger disabled   True         result   func  args    kwargs          logger disabled   prev state         return result     return wrapper   Then  you can do    disable debug messages def function already debugged                logger debug  This message won t be showed because of the decorator            def function being focused                logger debug  This message will be showed             Even if you call function already debugged from within function being focused  debug messages from function already debugged won t be showed   This ensures you will see only the debug messages from the function you are focusing on   Hope it helps

User · Answer

I found a solution for this   logger   logging getLogger  my-logger   logger propagate   False   now if you use logger it will not log to console    This will prevent logging from being send to the upper logger that includes the console logging

User · Answer

I don t know the logging module very well  but I m using it in the way that I usually want to disable only debug  or info  messages  You can use Handler setLevel   to set the logging level to CRITICAL or higher   Also  you could replace sys stderr and sys stdout by a file open for writing  See http   docs python org library sys html sys stdout  But I wouldn t recommend that

User · Answer

By changing one level in the  logging config dictConfig  you ll be able to take the whole logging level to a new level   logging config dictConfig    version   1   disable existing loggers   False   formatters          console              format      name -12s   levelname -8s   message s              file              format      asctime s   name -12s   levelname -8s   message s            handlers          console              class    logging StreamHandler            formatter    console          CHANGE below level from DEBUG to THE LEVEL YOU WANT TO SWITCH FOR  if we jump from DEBUG to INFO   we won t be able to see the DEBUG logs in our logging log file      file              level    DEBUG            class    logging FileHandler            formatter    file            filename    logging log             loggers                        level    DEBUG            handlers     console    file             propagate   False

User · Answer

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 do one of the following   Set the level of the logger to logging CRITICAL   1   Using the main API  import logging  logger   logging getLogger  quot foo quot   logger setLevel logging CRITICAL   1    Using the config API  import logging config  logging config dictConfig        quot version quot   1       quot loggers quot              quot foo quot                  quot level quot   logging CRITICAL   1                        Add a filter lambda record  False to the logger   Using the main API  import logging  logger   logging getLogger  quot foo quot   logger addFilter lambda record  False    Using the config API  import logging config  logging config dictConfig        quot version quot   1       quot filters quot              quot all quot                  quot    quot   lambda   lambda record  False                        quot loggers quot              quot foo quot                  quot filters quot     quot all quot                          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  quot foo quot   for handler in logger handlers copy        logger removeHandler handler  logger addHandler logging NullHandler    logger propagate   False   Using the config API  import logging config  logging config dictConfig        quot version quot   1       quot handlers quot              quot null quot                  quot class quot    quot logging NullHandler quot                        quot loggers quot              quot foo quot                  quot handlers quot     quot null quot                 quot propagate quot   False                         Warning      Contrary to approaches 1 and 2 which only prevent events logged by the logger from being emitted by the handlers of the logger and its ancestor loggers  approach 3 also prevents events logged by the descendant loggers of the logger  e g  logging getLogger  quot foo bar quot    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 approach  as it is not part of the public API  See https   bugs python org issue36318  import logging  logger   logging getLogger  quot foo quot   logger disabled   True    DO NOT DO THIS

User · Answer

long dead question  but for future searchers   Closer to the original poster s code intent  this works for me under python 2 6     usr bin python import logging  logger   logging getLogger     this gets the root logger  lhStdout   logger handlers 0     stdout is the only handler initially        here I add my own handlers  f   open   tmp debug   w              example handler lh   logging StreamHandler f  logger addHandler lh   logger removeHandler lhStdout   logger debug  bla bla     The gotcha I had to work out was to remove the stdout handler after adding a new one  the logger code appears to automatically re-add the stdout if no handlers are present

User · Answer

You can use  logging basicConfig level your level   where your level is one of those   debug   logging DEBUG   info   logging INFO   warning   logging WARNING   error   logging ERROR   critical   logging CRITICAL  So  if you set your level to logging CRITICAL  you will get only critical messages sent by  logging critical  This is a critical error message    Setting your level to logging DEBUG will show all levels of logging  For more details  please take a look at logging examples  In the same manner to change level for each Handler use Handler setLevel   function  import logging import logging handlers  LOG FILENAME     tmp logging rotatingfile example out     Set up a specific logger with our desired output level my logger   logging getLogger  MyLogger   my logger setLevel logging DEBUG     Add the log message handler to the logger handler   logging handlers RotatingFileHandler            LOG FILENAME  maxBytes 20  backupCount 5   handler setLevel logging CRITICAL   my logger addHandler handler

User · Answer

There are some really nice answers here  but apparently the simplest is not taken too much in consideration  only from infinito    root logger   logging getLogger   root logger disabled   True   This disables the root logger  and thus all the other loggers  I haven t really tested but it should be also the fastest   From the logging code in python 2 7 I see this  def handle self  record               Call the handlers for the specified record       This method is used for unpickled records received from a socket  as     well as those created locally  Logger-level filtering is applied              if  not self disabled  and self filter record           self callHandlers record    Which means that when it s disabled no handler is called  and it should be more efficient that filtering to a very high value or setting a no-op handler for example

User · Answer

This will prevent all logging from a third library which it used as decribed here https   docs python org 3 howto logging html configuring-logging-for-a-library logging getLogger  somelogger   addHandler logging NullHandler

User · Answer

Using Context manager -   most simple   import logging   class DisableLogger        def   enter   self          logging disable logging CRITICAL      def   exit   self  exit type  exit value  exit traceback          logging disable logging NOTSET   Example of use  with DisableLogger        do something    If you need a  more COMPLEX  fine-grained solution you can look at AdvancedLogger AdvancedLogger can be used for fine grained logging temporary modifications  How it works  Modifications will be enabled when context manager decorator starts working and be reverted after  Usage  AdvancedLogger can be used - as decorator   AdvancedLogger    - as context manager  with  AdvancedLogger      It has three main functions features  - disable loggers and it s handlers by using disable logger  argument - enable change loggers and it s handlers by using enable logger  argument - disable specific handlers for all loggers  by using  disable handler  argument  All features they can be used together  Use cases for AdvancedLogger   Disable specific logger handler  for example for stripe logger disable console AdvancedLogger disable logger   quot stripe quot    quot console quot    AdvancedLogger disable logger   quot stripe quot     quot console quot    quot console2 quot        Enable Set loggers   Set level for  quot stripe quot  logger to 50 AdvancedLogger enable logger   quot stripe quot   50   AdvancedLogger enable logger   quot stripe quot     quot level quot   50   quot propagate quot   True       Adjust already registered handlers AdvancedLogger enable logger   quot stripe quot     quot handlers quot    quot console quot

[python] How to disable logging on the standard error stream in Python?

Examples related to python

Examples related to logging

Examples related to console

Examples related to stdout