Как отключить и снова включить консольное ведение журнала в Python?

Я использую модуль логов Python и хочу на некоторое время отключить ведение логов консоли, но это не работает.

#!/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")

Приведенный выше код отображает bla blaon-stdout, и я не знаю, как можно безопасно отключить обработчик консоли. Как я могу быть уверен, что я временно удаляю консоль StreamHandler, а не другую?

Я нашел решение для этого:

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

Это предотвратит отправку журналов на верхний регистратор, который включает журналирование консоли.

Я использую:

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

Ты можешь использовать:

logging.basicConfig(level=your_level)

где ваш_уровень является одним из таких:

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

Итак, если вы установите your_level в logging.CRITICAL , вы получите только критические сообщения , отправленные:

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

Установка your_level для ведения журнала. DEBUG покажет все уровни ведения журнала.

Для более подробной информации, пожалуйста, взгляните на примеры регистрации.

Таким же образом, чтобы изменить уровень для каждого обработчика, используйте функцию 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)

(давно мертвый вопрос, но для будущих искателей)

Ближе к исходному коду / намерению автора, это работает для меня в 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")

Я должен был решить, что нужно убрать обработчик stdout после добавления нового; Код регистратора автоматически добавляет stdout, если нет обработчиков.

Контекстный менеджер

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

Пример использования:

with DisableLogger():
    do_something()

Чтобы полностью отключить ведение журнала :

logging.disable(sys.maxint) # Python 2

logging.disable(sys.maxsize) # Python 3

Чтобы включить ведение журнала :

logging.disable(logging.NOTSET)

Другие ответы обеспечивают обходные пути, которые не полностью решают проблему, такие как

logging.getLogger().disabled = True

и для некоторых nбольше 50,

logging.disable(n)

Проблема с первым решением заключается в том, что он работает только для корневого регистратора. Другие регистраторы, созданные, скажем, logging.getLogger(__name__)не отключаются этим методом.

Второе решение влияет на все журналы. Но это ограничивает вывод уровнями выше заданного, так что можно переопределить его, войдя в систему с уровнем выше 50.

Это может быть предотвращено

logging.disable(sys.maxint)

что, насколько я могу судить (после просмотра источника ), является единственным способом полностью отключить ведение журнала.

Здесь есть несколько действительно хороших ответов, но, видимо, самый простой не принимается во внимание (только от Infinito).

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

Это отключает корневой регистратор и, следовательно, все остальные регистраторы. Я действительно не проверял, но это должно быть также самым быстрым.

Из кода входа в Python 2.7 я вижу это

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)

Это означает, что когда он отключен, никакой обработчик не вызывается, и он должен быть более эффективным, чем фильтрация с очень высоким значением или установка, например, неоперативного обработчика.

Не нужно отвлекать стандартный вывод. Вот лучший способ сделать это:

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

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

Еще более простой способ:

logging.getLogger().setLevel(100)

Я не очень хорошо знаю модуль регистрации, но я использую его так, как обычно хочу отключить только сообщения отладки (или информацию). Вы можете использовать, Handler.setLevel()чтобы установить уровень регистрации на КРИТИЧЕСКИЙ или выше.

Также вы можете заменить sys.stderr и sys.stdout файлом, открытым для записи. См. Http://docs.python.org/library/sys.html#sys. стандартный вывод . Но я бы не рекомендовал это.

Вы также можете:

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

Консольный вывод:

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:

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

Изменяя один уровень в «logging.config.dictConfig», вы сможете поднять весь уровень ведения журнала на новый уровень.

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

})

Нашли элегантное решение с использованием декораторов , которое решает следующую проблему: что, если вы пишете модуль с несколькими функциями, каждая из которых имеет несколько сообщений отладки, и вы хотите отключить вход во все функции, кроме той, на которой вы сейчас сосредоточены?

Вы можете сделать это с помощью декораторов:

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

Затем вы можете сделать:

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

Даже если вы позвоните function_already_debuggedизнутри function_being_focused, отладочные сообщения function_already_debuggedне будут показаны. Это гарантирует, что вы увидите только отладочные сообщения от функции, на которой вы сосредоточены.

Надеюсь, поможет!

Если вы хотите временно отключить определенный регистратор, вот что сделано.

Пример журнала

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

Код

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

В библиотеке Logging Python можно полностью отключить ведение журналов (для всех уровней) для конкретного регистратора, выполнив одно из следующих действий:

1. Добавление в регистратор logging.NullHandler()обработчика (чтобы logging.lastResortобработчик не регистрировал события серьезности logging.WARNINGи выше sys.stderr) и установки propagateатрибута этого регистратора вFalse (чтобы регистратор не передавал события обработчикам своих регистраторов-предков).

   • Используя основной API:

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

   • Используя API конфигурации:

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

2. Добавление в логгер lambda record: Falseфильтра.

   • Используя основной API:

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

   • Используя API конфигурации:

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

Предупреждение. - В отличие от 1-го решения, 2-е решение не отключает ведение журнала от дочерних регистраторов (например logging.getLogger("foo.bar")), поэтому его следует использовать только для отключения ведения журнала для одного регистратора.

Заметка. - Установка disabledатрибута логгера Trueне является третьим решением, так как он не является частью общедоступного API. Смотрите https://bugs.python.org/issue36318 :

import logging

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

подкласс обработчик, который вы хотите временно отключить:

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)

найти обработчик по имени довольно просто:

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

однажды найденный:

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