Làm cách nào để vô hiệu hóa và kích hoạt lại đăng nhập bảng điều khiển trong Python?

Tôi đang sử dụng mô đun ghi nhật ký của Python và tôi muốn vô hiệu hóa việc ghi nhật ký bàn điều khiển một thời gian nhưng nó không hoạt động.

#!/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ạn mã trên hiển thị bla blathiết bị xuất chuẩn và tôi không biết làm cách nào để vô hiệu hóa trình xử lý bảng điều khiển một cách an toàn. Làm thế nào tôi có thể chắc chắn rằng tôi tạm thời gỡ bỏ giao diện điều khiển StreamHandler chứ không phải một cái khác?

Tôi tìm thấy một giải pháp cho việc này:

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

Điều này sẽ ngăn việc đăng nhập được gửi đến bộ ghi trên bao gồm ghi nhật ký giao diện điều khiển.

Tôi sử dụng:

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

Bạn có thể dùng:

logging.basicConfig(level=your_level)

trong đó your_level là một trong số đó:

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

Vì vậy, nếu bạn đặt your_level để logging.CRITICAL , bạn sẽ nhận được tin nhắn duy nhất quan trọng gửi bởi:

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

Thiết your_level để logging.DEBUG sẽ hiển thị tất cả các cấp khai thác gỗ.

Để biết thêm chi tiết, xin vui lòng xem các ví dụ đăng nhập.

Theo cách tương tự để thay đổi cấp độ cho mỗi Handler, hãy sử dụng hàm 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)

(câu hỏi đã chết từ lâu, nhưng dành cho những người tìm kiếm trong tương lai)

Gần hơn với mã / mục đích của người gửi ban đầu, điều này hoạt động với tôi theo 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 tôi phải làm việc là loại bỏ trình xử lý xuất sắc sau khi thêm một trình xử lý mới; mã logger xuất hiện để tự động thêm lại thiết bị xuất chuẩn nếu không có trình xử lý nào xuất hiện.

Quản lý bối cảnh

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

Ví dụ sử dụng:

with DisableLogger():
    do_something()

Để vô hiệu hóa hoàn toàn việc đăng nhập :

logging.disable(sys.maxint) # Python 2

logging.disable(sys.maxsize) # Python 3

Để cho phép đăng nhập :

logging.disable(logging.NOTSET)

Các câu trả lời khác cung cấp công việc xung quanh mà không giải quyết được hoàn toàn vấn đề, chẳng hạn như

logging.getLogger().disabled = True

và, đối với một số nlớn hơn 50,

logging.disable(n)

Vấn đề với giải pháp đầu tiên là nó chỉ hoạt động cho bộ ghi gốc. Các logger khác được tạo bằng cách sử dụng, giả sử, logging.getLogger(__name__)không bị vô hiệu hóa bởi phương thức này.

Giải pháp thứ hai không ảnh hưởng đến tất cả các bản ghi. Nhưng nó giới hạn đầu ra ở các mức trên mức đã cho, vì vậy người ta có thể ghi đè lên nó bằng cách đăng nhập với mức lớn hơn 50.

Điều đó có thể được ngăn chặn bởi

logging.disable(sys.maxint)

mà theo như tôi có thể nói (sau khi xem lại nguồn ) là cách duy nhất để vô hiệu hóa hoàn toàn việc ghi nhật ký.

Có một số câu trả lời thực sự hay ở đây, nhưng rõ ràng là đơn giản nhất không được xem xét quá nhiều (chỉ từ infinito).

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

Điều này vô hiệu hóa logger gốc, và do đó tất cả các logger khác. Tôi chưa thực sự thử nghiệm nhưng nó cũng phải nhanh nhất.

Từ mã đăng nhập trong python 2.7 tôi thấy điều này

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)

Điều đó có nghĩa là khi nó bị vô hiệu hóa, không có trình xử lý nào được gọi và sẽ hiệu quả hơn khi lọc thành giá trị rất cao hoặc đặt trình xử lý no-op chẳng hạn.

Không cần phải chuyển hướng stdout. Đây là cách tốt hơn để làm điều đó:

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

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

Một cách thậm chí đơn giản hơn là:

logging.getLogger().setLevel(100)

Tôi không biết rõ về mô-đun ghi nhật ký, nhưng tôi đang sử dụng nó theo cách mà tôi thường chỉ muốn vô hiệu hóa các thông báo gỡ lỗi (hoặc thông tin). Bạn có thể sử dụng Handler.setLevel()để đặt mức ghi nhật ký thành TIÊU CHUẨN hoặc cao hơn.

Ngoài ra, bạn có thể thay thế sys.stderr và sys.stdout bằng một tệp mở để viết. Xem http://docs.python.org/l Library / sys.html # sys. xuất sắc . Nhưng tôi không khuyến khích điều đó.

Bạn cũng có thể:

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

Bảng điều khiển đầu ra:

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

nội dung tập tin 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

Bằng cách thay đổi một cấp độ trong "log.config.dictConfig", bạn sẽ có thể đưa toàn bộ cấp độ đăng nhập lên một cấp độ mới.

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

})

Tìm thấy một giải pháp tao nhã bằng cách sử dụng các trình trang trí , giải quyết vấn đề sau: nếu bạn đang viết một mô-đun với một số chức năng, mỗi chức năng có một số thông báo gỡ lỗi và bạn muốn tắt đăng nhập trong tất cả các chức năng nhưng bạn đang tập trung vào?

Bạn có thể làm điều đó bằng cách sử dụng trang trí:

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

Sau đó, bạn có thể làm:

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

Ngay cả khi bạn gọi function_already_debuggedtừ bên trong function_being_focused, các thông báo gỡ lỗi từ function_already_debuggedsẽ không được hiển thị. Điều này đảm bảo bạn sẽ chỉ thấy các thông báo gỡ lỗi từ chức năng bạn đang tập trung vào.

Hy vọng nó giúp!

Nếu bạn muốn vô hiệu hóa một logger nhất định ở đây là những gì đã làm.

Nhật ký mẫu

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

Mã

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

Trong thư viện Ghi nhật ký Python, người ta hoàn toàn có thể vô hiệu hóa ghi nhật ký (cho tất cả các cấp) cho một trình ghi nhật ký cụ thể bằng cách thực hiện một trong các thao tác sau:

1. Thêm vào logger một logging.NullHandler()trình xử lý (để ngăn logging.lastResorttrình xử lý ghi nhật ký các sự kiện nghiêm trọng logging.WARNINGvà lớn hơn sys.stderr) và đặt propagatethuộc tính của logger đóFalse (để ngăn logger truyền các sự kiện cho các trình xử lý của logger tổ tiên của nó).

   • Sử dụng API chính:

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

   • Sử dụng API cấu hình:

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

2. Thêm vào logger một lambda record: Falsebộ lọc.

   • Sử dụng API chính:

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

   • Sử dụng API cấu hình:

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

Cảnh báo. - Trái ngược với giải pháp thứ 1, giải pháp thứ 2 không vô hiệu hóa ghi nhật ký từ logger con (ví dụ logging.getLogger("foo.bar")), do đó, người ta chỉ nên sử dụng nó để vô hiệu hóa ghi nhật ký cho một logger.

Ghi chú. - Đặt disabledthuộc tính của logger Truekhông phải là giải pháp thứ 3, vì nó không phải là một phần của API công khai. Xem https://bugs.python.org/su36318 :

import logging

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

phân lớp trình xử lý mà bạn muốn có thể tắt tạm thời:

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)

Tìm trình xử lý theo tên khá dễ dàng:

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

một khi được tìm thấy:

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