Como desativar e reativar o log do console no Python?

Estou usando o módulo de log do Python e quero desativar o log do console por algum tempo, mas ele não funciona.

#!/usr/bin/python
import logging

logger = logging.getLogger() # this gets the root logger
# ... here I add my own handlers 
#logger.removeHandler(sys.stdout)
#logger.removeHandler(sys.stderr)

print logger.handlers 
# this will print [<logging.StreamHandler instance at ...>]
# but I may have other handlers there that I want to keep

logger.debug("bla bla")

O código acima exibe o bla blaon stdout e não sei como posso desativar com segurança o manipulador do console. Como posso ter certeza de remover temporariamente o StreamHandler do console e não outro?

Encontrei uma solução para isso:

logger = logging.getLogger('my-logger')
logger.propagate = False
# now if you use logger it will not log to console.

Isso impedirá que o log seja enviado ao logger superior que inclui o log do console.

Eu uso:

logger = logging.getLogger()
logger.disabled = True
... whatever you want ...
logger.disabled = False

Você pode usar:

logging.basicConfig(level=your_level)

onde your_level é um deles:

      'debug': logging.DEBUG,
      'info': logging.INFO,
      'warning': logging.WARNING,
      'error': logging.ERROR,
      'critical': logging.CRITICAL

Portanto, se você definir seu_level como log.CRITICAL , receberá apenas mensagens críticas enviadas por:

logging.critical('This is a critical error message')

Configurando seu_level para o log.DEBUG mostrará todos os níveis de log.

Para mais detalhes, consulte exemplos de registro.

Da mesma maneira para alterar o nível de cada manipulador, use a função Handler.setLevel () .

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)

(pergunta há muito morta, mas para futuros pesquisadores)

Mais próximo do código / intenção do pôster original, isso funciona para mim no 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")

O problema que tive que resolver foi remover o manipulador stdout após adicionar um novo; o código do criador de logs parece adicionar novamente o stdout automaticamente se nenhum manipulador estiver presente.

Gerenciador de contexto

import logging 
class DisableLogger():
    def __enter__(self):
       logging.disable(logging.CRITICAL)
    def __exit__(self, a, b, c):
       logging.disable(logging.NOTSET)

Exemplo de uso:

with DisableLogger():
    do_something()

Para desativar totalmente o log :

logging.disable(sys.maxint) # Python 2

logging.disable(sys.maxsize) # Python 3

Para habilitar o log :

logging.disable(logging.NOTSET)

Outras respostas fornecem soluções alternativas que não resolvem completamente o problema, como

logging.getLogger().disabled = True

e, para alguns nsuperiores a 50,

logging.disable(n)

O problema com a primeira solução é que ele funciona apenas para o registrador raiz. Outros criadores de logs criados usando, por exemplo, logging.getLogger(__name__)não são desativados por esse método.

A segunda solução afeta todos os logs. Mas limita a saída a níveis acima do fornecido, para que você possa substituí-la registrando-se em um nível superior a 50.

Isso pode ser evitado por

logging.disable(sys.maxint)

que até onde eu sei (depois de revisar a fonte ) é a única maneira de desativar completamente o log.

Existem algumas respostas muito legais aqui, mas aparentemente a mais simples não é levada muito em consideração (apenas a partir do infinito).

root_logger = logging.getLogger()
root_logger.disabled = True

Isso desativa o registrador raiz e, portanto, todos os outros registradores. Eu realmente não testei, mas também deve ser o mais rápido.

No código de log do python 2.7, vejo isso

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)

O que significa que, quando desabilitado, nenhum manipulador é chamado e deve ser mais eficiente filtrar para um valor muito alto ou definir um manipulador não operacional, por exemplo.

Não há necessidade de desviar o desvio padrão. Aqui está a melhor maneira de fazer isso:

import logging
class MyLogHandler(logging.Handler):
    def emit(self, record):
        pass

logging.getLogger().addHandler(MyLogHandler())

Uma maneira ainda mais simples é:

logging.getLogger().setLevel(100)

Não conheço o módulo de registro muito bem, mas estou usando-o da maneira que geralmente quero desativar apenas as mensagens de depuração (ou informações). Você pode usar Handler.setLevel()para definir o nível de log como CRÍTICO ou superior.

Além disso, você pode substituir sys.stderr e sys.stdout por um arquivo aberto para gravação. Consulte http://docs.python.org/library/sys.html#sys. stdout . Mas eu não recomendaria isso.

Você também pode:

handlers = app.logger.handlers
# detach console handler
app.logger.handlers = []
# attach
app.logger.handlers = handlers

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')

Saída do console:

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

conteúdo do arquivo test.log:

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

Alterando um nível no "logging.config.dictConfig", você poderá levar todo o nível de log para um novo nível.

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,
    },
}

})

Encontrou uma solução elegante usando decoradores , que soluciona o seguinte problema: e se você estiver escrevendo um módulo com várias funções, cada uma com várias mensagens de depuração, e quiser desativar o log de todas as funções, exceto aquela em que está focando atualmente?

Você pode fazer isso usando decoradores:

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

Então, você pode fazer:

@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")
    ...

Mesmo se você ligar function_already_debuggedde dentro function_being_focused, as mensagens de depuração de function_already_debuggednão serão exibidas. Isso garante que você verá apenas as mensagens de depuração da função em que está se concentrando.

Espero que ajude!

Se você deseja desativar temporariamente um certo criador de logs, aqui está o que foi feito.

Exemplo de log

2019-10-02 21:28:45,663 django.request PID: 8  Internal Server Error: /service_portal/get_all_sites

Código

django_request_logger = logging.getLogger('django.request')
django_request_logger.disabled = True
django_request_logger.disabled = False

Na biblioteca Logging Python, é possível desativar completamente o log (para todos os níveis) de um logger específico, executando um dos seguintes procedimentos:

1. Incluindo no criador de logs um logging.NullHandler()manipulador (para impedir que o logging.lastResortmanipulador registre eventos de gravidade logging.WARNINGe maiores que sys.stderr) e configurando o propagateatributo desse criador de logs paraFalse (para impedir que o criador de logs passe os eventos para os manipuladores dos criadores de logs ancestrais).

   • Usando a API principal:

     import logging
     
     logging.getLogger("foo").addHandler(logging.NullHandler())
     logging.getLogger("foo").propagate = False

   • Usando a API de configuração:

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

2. Adicionando ao criador de logs um lambda record: Falsefiltro.

   • Usando a API principal:

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

   • Usando a API de configuração:

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

Aviso. - Ao contrário da 1ª solução, a 2ª solução não desabilita o log de registradores filhos (por exemplo logging.getLogger("foo.bar")), portanto, deve-se usá-lo apenas para desativar o log de um único logger.

Nota. - Definir o disabledatributo do criador de logs como Truenão é uma terceira solução, pois não faz parte da API pública. Consulte https://bugs.python.org/issue36318 :

import logging

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

subclasse o manipulador que você deseja desativar temporariamente:

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)

encontrar o manipulador pelo nome é bastante fácil:

_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))

uma vez encontrado:

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