Bagaimana cara menonaktifkan dan mengaktifkan kembali logging konsol di Python?

Saya menggunakan modul logging Python dan saya ingin menonaktifkan konsol logging untuk beberapa waktu tetapi tidak berhasil.

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

Kode di atas menampilkan bla blaon stdout dan saya tidak tahu bagaimana cara menonaktifkan konsol handler dengan aman. Bagaimana saya bisa yakin bahwa saya sementara menghapus StreamHandler konsol dan bukan yang lain?

Saya menemukan solusi untuk ini:

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

Ini akan mencegah logging dari dikirim ke logger atas yang mencakup logging konsol.

Saya menggunakan:

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

Kamu bisa memakai:

logging.basicConfig(level=your_level)

di mana your_level adalah salah satunya:

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

Jadi, jika Anda mengatur tingkat_Anda ke logging.CRITICAL , Anda hanya akan menerima pesan-pesan penting yang dikirim oleh:

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

Mengatur tingkat_mu ke logging . Debug akan menunjukkan semua tingkat logging.

Untuk detail lebih lanjut, silakan lihat contoh logging.

Dengan cara yang sama untuk mengubah level untuk setiap Handler gunakan fungsi 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)

(pertanyaan lama, tetapi untuk pencari masa depan)

Lebih dekat ke kode / maksud poster asli, ini bekerja untuk saya di bawah 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")

Gotcha yang harus saya kerjakan adalah menghapus stdout handler setelah menambahkan yang baru; kode logger muncul untuk secara otomatis menambahkan kembali stdout jika tidak ada penangan yang hadir.

Manajer konteks

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

Contoh penggunaan:

with DisableLogger():
    do_something()

Untuk sepenuhnya menonaktifkan pencatatan :

logging.disable(sys.maxint) # Python 2

logging.disable(sys.maxsize) # Python 3

Untuk mengaktifkan pencatatan :

logging.disable(logging.NOTSET)

Jawaban lain memberikan solusi untuk masalah yang tidak sepenuhnya menyelesaikan masalah, seperti

logging.getLogger().disabled = True

dan, untuk beberapa yang nlebih besar dari 50,

logging.disable(n)

Masalah dengan solusi pertama adalah hanya berfungsi untuk root logger. Penebang lain yang dibuat menggunakan, katakanlah, logging.getLogger(__name__)tidak dinonaktifkan oleh metode ini.

Solusi kedua tidak mempengaruhi semua log. Tapi itu membatasi output ke level di atas yang diberikan, jadi orang bisa menimpanya dengan login dengan level lebih besar dari 50.

Itu bisa dicegah dengan

logging.disable(sys.maxint)

yang sejauh yang saya tahu (setelah meninjau sumber ) adalah satu-satunya cara untuk menonaktifkan logging sepenuhnya.

Ada beberapa jawaban yang sangat bagus di sini, tetapi tampaknya yang paling sederhana tidak terlalu dipertimbangkan (hanya dari infinito).

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

Ini menonaktifkan logger root, dan dengan demikian semua logger lainnya. Saya belum benar-benar diuji tetapi harus juga yang tercepat.

Dari kode logging di python 2.7 saya melihat ini

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)

Yang berarti bahwa ketika dinonaktifkan tidak ada penangan yang dipanggil, dan itu harus lebih efisien bahwa penyaringan ke nilai yang sangat tinggi atau menetapkan penangan yang tidak ada op misalnya.

Tidak perlu mengalihkan stdout. Ini cara yang lebih baik untuk melakukannya:

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

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

Cara yang lebih sederhana adalah:

logging.getLogger().setLevel(100)

Saya tidak tahu modul logging dengan sangat baik, tetapi saya menggunakannya dengan cara yang biasanya saya ingin menonaktifkan hanya pesan debug (atau info). Kamu bisa memakaiHandler.setLevel() untuk mengatur level logging ke KRITIS atau lebih tinggi.

Anda juga dapat mengganti sys.stderr dan sys.stdout dengan file yang terbuka untuk ditulis. Lihat http://docs.python.org/library/sys.html#sys. stdout . Tapi saya tidak akan merekomendasikan itu.

Anda juga bisa:

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

Output konsol:

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

konten file 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

Dengan mengubah satu level di "logging.config.dictConfig" Anda akan dapat membawa keseluruhan level logging ke level baru.

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

})

Menemukan solusi elegan menggunakan dekorator , yang mengatasi masalah berikut: bagaimana jika Anda menulis modul dengan beberapa fungsi, masing-masing dengan beberapa pesan debug, dan Anda ingin menonaktifkan login di semua fungsi tapi yang sedang Anda fokuskan?

Anda dapat melakukannya menggunakan dekorator:

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

Kemudian, Anda dapat melakukan:

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

Bahkan jika Anda menelepon function_already_debuggeddari dalam function_being_focused, debug pesan darifunction_already_debugged tidak akan ditampilkan. Ini memastikan Anda hanya akan melihat pesan debug dari fungsi yang Anda fokuskan.

Semoga ini bisa membantu!

Jika Anda ingin menonaktifkan logger tertentu sementara di sini adalah apa yang dilakukan.

Contoh Log

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

Kode

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

Di pustaka Logging Python, seseorang dapat sepenuhnya menonaktifkan logging (untuk semua level) untuk logger tertentu dengan melakukan salah satu dari berikut ini:

1. Menambahkan ke logging.NullHandler()penangan pengendali (untuk mencegah logging.lastResortpenangan dari penebangan peristiwa keparahan logging.WARNINGdan lebih besar ke sys.stderr) dan mengatur propagateatribut pencatat itu untukFalse (untuk mencegah penebang meneruskan peristiwa ke penangan penebang leluhurnya).

   • Menggunakan API utama:

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

   • Menggunakan API konfigurasi:

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

2. Menambahkan lambda record: Falsefilter ke logger .

   • Menggunakan API utama:

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

   • Menggunakan API konfigurasi:

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

Peringatan.- Bertentangan dengan solusi 1, solusi 2 tidak menonaktifkan logging dari penebang anak (misalnyalogging.getLogger("foo.bar") ), jadi orang harus menggunakannya hanya untuk menonaktifkan logging untuk logger tunggal.

Catatan. - Mengatur disabledatribut logger Truebukanlah solusi ke-3, karena ini bukan bagian dari API publik. Lihat https://bugs.python.org/issue36318 :

import logging

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

subkelas pawang yang ingin Anda nonaktifkan sementara:

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)

menemukan pawang dengan nama cukup mudah:

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

pernah ditemukan:

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