अजगर कुछ भी नहीं उत्पादन लॉगिंग

Question 1

एक अजगर स्क्रिप्ट में मैं लिख रहा हूं, मैं लॉगिंग मॉड्यूल का उपयोग करके घटनाओं को लॉग करने की कोशिश कर रहा हूं। मेरे लकड़हारे को कॉन्फ़िगर करने के लिए मेरे पास निम्नलिखित कोड है:

ERROR_FORMAT = "%(levelname)s at %(asctime)s in %(funcName)s in %(filename) at line %(lineno)d: %(message)s"
DEBUG_FORMAT = "%(lineno)d in %(filename)s at %(asctime)s: %(message)s"
LOG_CONFIG = {'version':1,
              'formatters':{'error':{'format':ERROR_FORMAT},
                            'debug':{'format':DEBUG_FORMAT}},
              'handlers':{'console':{'class':'logging.StreamHandler',
                                     'formatter':'debug',
                                     'level':logging.DEBUG},
                          'file':{'class':'logging.FileHandler',
                                  'filename':'/usr/local/logs/DatabaseUpdate.log',
                                  'formatter':'error',
                                  'level':logging.ERROR}},
              'root':{'handlers':('console', 'file')}}
logging.config.dictConfig(LOG_CONFIG)

जब मैं चलाने की कोशिश करता logging.debug("Some string")हूं, तो मुझे कंसोल के लिए कोई आउटपुट नहीं मिलता है, भले ही डॉक्स में यह पृष्ठ कहता है कि logging.debugसंदेश को रूट लकड़हारा आउटपुट होना चाहिए। मेरा प्रोग्राम कुछ भी आउटपुट क्यों नहीं कर रहा है, और मैं इसे कैसे ठीक कर सकता हूं?

Question 2

डिफ़ॉल्ट लॉगिंग स्तर चेतावनी दे रहा है। चूंकि आपने स्तर नहीं बदला है, इसलिए रूट लॉगर का स्तर अभी भी चेतावनी है। इसका मतलब है कि यह डिबग लॉगिंग सहित चेतावनी से कम स्तर वाले किसी भी लॉगिंग को अनदेखा करेगा।

यह ट्यूटोरियल में समझाया गया है :

import logging
logging.warning('Watch out!') # will print a message to the console
logging.info('I told you so') # will not print anything

'जानकारी' लाइन कुछ भी प्रिंट नहीं करती है, क्योंकि स्तर जानकारी से अधिक है।

स्तर बदलने के लिए, बस इसे रूट लॉगर में सेट करें:

'root':{'handlers':('console', 'file'), 'level':'DEBUG'}

दूसरे शब्दों में, यह स्तर = DEBUG के साथ एक हैंडलर को परिभाषित करने के लिए पर्याप्त नहीं है, इसे कुछ भी आउटपुट करने के लिए वास्तविक लॉगिंग स्तर भी DEBUG होना चाहिए।

Question 3

कई वर्षों के बाद भी लगता है कि पायथन लकड़हारे के साथ अभी भी एक समस्या है। यहाँ उदाहरण के साथ कुछ स्पष्टीकरण दिए गए हैं:

import logging
# This sets the root logger to write to stdout (your console).
# Your script/app needs to call this somewhere at least once.
logging.basicConfig()

# By default the root logger is set to WARNING and all loggers you define
# inherit that value. Here we set the root logger to NOTSET. This logging
# level is automatically inherited by all existing and new sub-loggers
# that do not set a less verbose level.
logging.root.setLevel(logging.NOTSET)

# The following line sets the root logger level as well.
# It's equivalent to both previous statements combined:
logging.basicConfig(level=logging.NOTSET)


# You can either share the `logger` object between all your files or the
# name handle (here `my-app`) and call `logging.getLogger` with it.
# The result is the same.
handle = "my-app"
logger1 = logging.getLogger(handle)
logger2 = logging.getLogger(handle)
# logger1 and logger2 point to the same object:
# (logger1 is logger2) == True


# Convenient methods in order of verbosity from highest to lowest
logger.debug("this will get printed")
logger.info("this will get printed")
logger.warning("this will get printed")
logger.error("this will get printed")
logger.critical("this will get printed")


# In large applications where you would like more control over the logging,
# create sub-loggers from your main application logger.
component_logger = logger.getChild("component-a")
component_logger.info("this will get printed with the prefix `my-app.component-a`")

# If you wish to control the logging levels, you can set the level anywhere 
# in the hierarchy:
#
# - root
#   - my-app
#     - component-a
#

# Example for development:
logger.setLevel(logging.DEBUG)

# If that prints too much, enable debug printing only for your component:
component_logger.setLevel(logging.DEBUG)


# For production you rather want:
logger.setLevel(logging.WARNING)

भ्रम का एक सामान्य स्रोत बुरी तरह से आरंभिक रूट लॉगर से आता है। इस पर विचार करो:

import logging
log = logging.getLogger("myapp")
log.warning("woot")
logging.basicConfig()
log.warning("woot")

आउटपुट:

woot
WARNING:myapp:woot

आपके रनटाइम वातावरण और लॉगिंग स्तरों के आधार पर, पहली लॉग लाइन (मूल कॉन्फ़िगरेशन से पहले) कहीं भी दिखाई नहीं दे सकती है ।

Question 4

यहाँ किसी के लिए जो एक सुपर-सरल उत्तर चाहता है: बस वह स्तर सेट करें जिसे आप प्रदर्शित करना चाहते हैं। मेरी सभी लिपियों में मैं सबसे ऊपर हूं:

import logging
logging.basicConfig(level = logging.INFO)

फिर उस स्तर पर या उससे ऊपर कुछ भी प्रदर्शित करने के लिए:

logging.info("Hi you just set your fleeb to level plumbus")

यह पाँच स्तरों का एक पदानुक्रमित सेट है जिससे लॉग आपके द्वारा सेट किए गए स्तर या उच्चतर पर प्रदर्शित होंगे । इसलिए यदि आप एक ऐसी त्रुटि प्रदर्शित करना चाहते हैं जिसका आप उपयोग कर सकते हैं logging.error("The plumbus is broken")।

स्तर, गंभीरता के बढते क्रम में, कर रहे हैं DEBUG, INFO, WARNING, ERROR, और CRITICAL। डिफ़ॉल्ट सेटिंग है WARNING।

यह एक अच्छा लेख है, जिसमें इस जानकारी को मेरे उत्तर से बेहतर व्यक्त किया गया है:
https://www.digitalocean.com/community/tutorials/how-to-use-log-in-python-3

Question 5

शायद यह कोशिश करो? ऐसा लगता है कि मेरे मामले में सभी संचालकों को हटाने के बाद समस्या हल हो गई है।

for handler in logging.root.handlers[:]:
    logging.root.removeHandler(handler)

logging.basicConfig(filename='output.log', level=logging.INFO)