วิธีการปิดการใช้งานและเปิดใช้งานการบันทึกคอนโซลใน 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 blaบน 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)

โดยที่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เป็นlogging.DEBUGจะแสดงการบันทึกทุกระดับ

สำหรับรายละเอียดเพิ่มเติมโปรดดูตัวอย่างการบันทึก

ในลักษณะเดียวกันกับระดับการเปลี่ยนแปลงสำหรับแต่ละ Handler ใช้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")

gotcha ที่ฉันต้องทำงานคือลบตัวจัดการ 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)

ฉันไม่รู้จักโมดูลการบันทึกเป็นอย่างดี แต่ฉันใช้มันในแบบที่ฉันต้องการปิดการใช้งานเฉพาะข้อความ debug (หรือข้อมูล) คุณสามารถใช้Handler.setLevel()เพื่อตั้งค่าระดับการบันทึกเป็นอย่างยิ่งหรือสูงกว่า

นอกจากนี้คุณสามารถแทนที่ sys.stderr และ sys.stdout ด้วยไฟล์ที่เปิดเพื่อการเขียน ดูhttp://docs.python.org/library/sys.html#sys stdout แต่ฉันไม่อยากจะแนะนำ

คุณสามารถ:

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

   • การใช้ config 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)

   • การใช้ config 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เป็นไม่ใช่โซลูชันที่ 3 เนื่องจากไม่ใช่ส่วนหนึ่งของ 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()