Python'da konsol günlüğü nasıl devre dışı bırakılır ve yeniden etkinleştirilir?

Python'un günlük modülünü kullanıyorum ve konsol günlüğünü bir süreliğine devre dışı bırakmak istiyorum ancak çalışmıyor.

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

Yukarıdaki kod bla blastdout'ta görüntülenir ve konsol işleyicisini nasıl güvenli bir şekilde devre dışı bırakabileceğimi bilmiyorum. Başka bir konsolu değil geçici olarak StreamHandler konsolunu kaldırdığımdan nasıl emin olabilirim?

Bunun için bir çözüm buldum:

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

Bu, günlüğün konsol günlüğünü içeren üst günlüğe gönderilmesini engelleyecektir.

Kullanırım:

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

Kullanabilirsiniz:

logging.basicConfig(level=your_level)

burada seviyeniz bunlardan biridir:

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

Belirlediğiniz Yani, your_level için logging.CRITICAL , sen tarafından gönderilen yalnızca kritik mesajlar alacak:

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

Ayar your_level için logging.DEBUG günlük bütün seviyelerini gösterecektir.

Daha fazla ayrıntı için lütfen günlüğe kaydetme örneklerine göz atın .

Her Handler için seviyeyi değiştirmek için aynı şekilde Handler.setLevel () fonksiyonunu kullanın .

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)

(uzun ölü soru, ancak gelecekteki araştırmacılar için)

Orijinal posterin koduna / amacına daha yakın, bu benim için python 2.6 altında çalışıyor

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

Çalışmak zorunda kaldım, yeni bir tane ekledikten sonra stdout işleyicisini çıkarmaktı ; hiçbir işleyici yoksa, günlükçü kodu stdout'u otomatik olarak yeniden ekler.

İçerik yöneticisi

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

Kullanım örneği:

with DisableLogger():
    do_something()

Günlük kaydını tamamen devre dışı bırakmak için :

logging.disable(sys.maxint) # Python 2

logging.disable(sys.maxsize) # Python 3

Günlüğe kaydetmeyi etkinleştirmek için :

logging.disable(logging.NOTSET)

Diğer cevaplar, sorunu tam olarak çözmeyen, örneğin

logging.getLogger().disabled = True

ve n50 yaşından büyükler için,

logging.disable(n)

İlk çözümle ilgili sorun, yalnızca kök kaydedici için çalışmasıdır. Diyelim ki logging.getLogger(__name__)bu yöntemle oluşturulan diğer kaydediciler bu yöntemle devre dışı bırakılmaz.

İkinci çözüm tüm günlükleri etkiler. Ancak çıktıyı verilenin üzerinde seviyelere sınırlar, böylece biri 50'den daha yüksek bir seviyeyle günlüğe kaydederek onu geçersiz kılabilir.

Bu önlenebilir

logging.disable(sys.maxint)

( kaynak inceledikten sonra ) günlüğe kaydetmeyi tamamen devre dışı bırakmanın tek yoludur.

Burada gerçekten güzel cevaplar var, ama görünüşe göre en basitleri çok fazla dikkate almıyor (sadece infinito'dan).

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

Bu, kök kaydedicisini ve böylece diğer tüm günlükleyicileri devre dışı bırakır. Gerçekten test etmedim ama aynı zamanda en hızlısı olmalı.

Python 2.7'deki günlük kodundan bunu görüyorum

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)

Bu, devre dışı bırakıldığında hiçbir işleyicinin çağrılmadığı ve örneğin çok yüksek bir değere göre filtrelemenin veya örneğin bir op-olmayan işleyicinin ayarlanmasının daha verimli olması gerektiği anlamına gelir.

Stdout'u yönlendirmeye gerek yok. İşte bunu yapmanın daha iyi bir yolu:

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

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

Daha da basit bir yol:

logging.getLogger().setLevel(100)

Günlük modülünü çok iyi bilmiyorum, ancak genellikle yalnızca hata ayıklama (veya bilgi) iletilerini devre dışı bırakmak istediğim şekilde kullanıyorum. Handler.setLevel()Günlük kaydı düzeyini CRITICAL veya daha yüksek bir değere ayarlamak için kullanabilirsiniz .

Ayrıca, sys.stderr ve sys.stdout dosyalarını yazmak için açık bir dosya ile değiştirebilirsiniz. Bkz. Http://docs.python.org/library/sys.html#sys. stdout . Ama bunu tavsiye etmem.

Ayrıca yapabilirdin:

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

Konsol çıkışı:

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 dosya içeriği:

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" içindeki bir düzeyi değiştirerek, tüm günlük kaydı düzeyini yeni bir düzeye taşıyabilirsiniz.

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

})

Dekoratörler kullanarak aşağıdaki sorunu ele alan zarif bir çözüm buldum : ya birkaç işlevi olan bir modül yazıyorsanız, her biri birkaç hata ayıklama mesajı olan ve şu anda odaklanmakta olduğunuz tüm işlevlerde günlüğe kaydetmeyi devre dışı bırakmak istiyorsanız ne olacak?

Dekoratörleri kullanarak yapabilirsiniz:

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

Sonra şunları yapabilirsiniz:

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

Aradığınızda bile function_already_debuggediçinden function_being_focusedgelen ayıklama mesajları function_already_debuggedirade değil gösterdi edilebilir. Bu, yalnızca odaklandığınız işlevdeki hata ayıklama iletilerini görmenizi sağlar.

Umarım yardımcı olur!

Belirli bir kaydediciyi geçici olarak devre dışı bırakmak istiyorsanız, işte burada ne var.

Örnek Günlük

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

kod

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

Günlük Python kitaplığında, aşağıdakilerden birini yaparak belirli bir günlükçünün günlük kaydını ( tüm düzeyler için) tamamen devre dışı bırakabilirsiniz :

1. Bir kaydedici ekleme logging.NullHandler()işleyici (önlemek için logging.lastResortşiddeti olaylarını açmasını işleyicisi logging.WARNINGiçin ve daha fazla sys.stderrve) ayarı propagateiçin bu kaydedicisi niteliğiniFalse (kendi soy kaydedicilerinin işleyicileri olayları geçmesini kayıt cihazı önlemek için).

   • Ana API'yı kullanma:

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

   • Yapılandırma API'sını kullanma:

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

2. Kaydediciye bir lambda record: Falsefiltre ekleme .

   • Ana API'yı kullanma:

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

   • Yapılandırma API'sını kullanma:

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

Uyarı. - 1. çözümün aksine, 2. çözüm alt günlüklerden (örneğin logging.getLogger("foo.bar")) günlüğe kaydetmeyi devre dışı bırakmaz , bu nedenle yalnızca tek bir günlükçü için günlüğe kaydetmeyi devre dışı bırakmak için kullanılmalıdır.

Not. - Günlük API'sının bir parçası olmadığı için günlükçünün disabledniteliğini ayarlamak True3. bir çözüm değildir. Bkz. Https://bugs.python.org/issue36318 :

import logging

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

geçici olarak devre dışı bırakmak istediğiniz işleyiciyi alt sınıflara ayırın:

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)

işleyiciyi adıyla bulmak oldukça kolaydır:

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

bir kez bulundu:

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