फिल्टर के साथ लॉगिंग

Question

मै मैसेज लॉग करने के लिए लॉगिंग (आयात लॉगिंग) का उपयोग कर रहा हूं।

1 एकल मॉड्यूल के भीतर, मैं डिबग स्तर पर संदेश (my_logger.debug ('संदेश')) प्रवेश करने कर रहा हूँ; function_b से

इन डिबग संदेशों के कुछ function_a से आते हैं() और अन्य(); मैं लॉगिंग को सक्षम/अक्षम करने में सक्षम होना चाहता हूं कि वे बी से या उससे आते हैं;

मुझे लगता है कि मुझे लॉगिंग के फ़िल्टरिंग तंत्र का उपयोग करना है।

कोई मुझे दिखाने कृपया सकते हैं कि कैसे कोड के नीचे मैं क्या चाहता हूं instrumented करने की आवश्यकता होगी? धन्यवाद।

import logging 
logger= logging.getLogger("module_name") 

def function_a(...): 
    logger.debug("a message") 

def function_b(...): 
    logger.debug("another message") 

if __name__ == "__main__": 
    logging.basicConfig(stream=sys.stderr, level=logging.DEBUG) 

    #don't want function_a()'s noise -> .... 
    #somehow filter-out function_a's logging 
    function_a() 

    #don't want function_b()'s noise -> .... 
    #somehow filter-out function_b's logging 
    function_b() 

अगर मैं अधिक मॉड्यूल और मॉड्यूल प्रति अधिक funcs को यह सरल उदाहरण बढ़ाया, मैं वालों के बहुत सारे के बारे में चिंतित हो जाएगा;

क्या मैं इसे प्रति मॉड्यूल 1 लॉगर तक रख सकता हूं? ध्यान दें कि लॉग संदेश "संरचित" हैं, यानी यदि फ़ंक्शन लॉगिंग कर रहे हैं तो यह कुछ पार्सिंग कार्य कर रहे हैं, उनमें सभी में एक उपसर्ग लॉगजर है .debug ("पार्सिंग: xxx") - क्या मैं किसी भी तरह से एक लाइन के साथ बंद कर सकता हूं बंद सभी "पार्स" संदेश (की परवाह किए बिना मॉड्यूल/समारोह संदेश उत्सर्जक?)

Answer 1

बस logging.Filter का एक उपवर्ग को लागू। इसमें एक विधि होगी, filter(record), जो लॉग रिकॉर्ड की जांच करता है और इसे लॉग करने के लिए सही लौटाता है या इसे छोड़ने के लिए गलत है। फिर आप या Handler पर फ़िल्टर को addFilter(filter) विधि पर कॉल करके इंस्टॉल कर सकते हैं।

उदाहरण:

class NoParsingFilter(logging.Filter): 
    def filter(self, record): 
     return not record.getMessage().startswith('parsing') 

logger.addFilter(NoParsingFilter()) 

या कुछ ऐसे ही, वैसे भी।

Answer 2

वैश्विक प्रयोग न करें। यह एक दुर्घटना होने का इंतजार कर रहा है। अलग करते है कि आप को सार्थक कर रहे हैं -

आप अपने वालों किसी भी दे सकते हैं "।"।

आप उन्हें पदानुक्रम के रूप में नियंत्रित कर सकते हैं। अगर आपके पास a.b.c और a.b.d नामक लॉगर्स हैं, तो आप a.b के लिए लॉगिंग स्तर की जांच कर सकते हैं और दोनों लॉगर्स बदल सकते हैं।

आपके पास लॉगजर की संख्या हो सकती है - वे सस्ती हैं।

सबसे आम डिजाइन पैटर्न प्रति मॉड्यूल एक लॉगर है। Naming Python loggers

ऐसा करें देखें। http://docs.python.org/library/logging.html#filter-objects:

import logging 

logger= logging.getLogger("module_name") 
logger_a = logger.getLogger("module_name.function_a") 
logger_b = logger.getLogger("module_name.function_b") 

def function_a(...): 
    logger_a.debug("a message") 

def functio_b(...): 
    logger_b.debug("another message") 

if __name__ == "__main__": 
    logging.basicConfig(stream=sys.stderr, level=logging.DEBUG) 
    logger_a.setLevel(logging.DEBUG) 
    logger_b.setLevel(logging.WARN) 

    ... etc ...