Python Language
लॉगिंग

पायथन लॉगिंग का परिचय

यह मॉड्यूल कार्यों और कक्षाओं को परिभाषित करता है जो अनुप्रयोगों और पुस्तकालयों के लिए एक लचीली घटना लॉगिंग प्रणाली को लागू करते हैं।

एक मानक पुस्तकालय मॉड्यूल द्वारा प्रदान की गई लॉगिंग एपीआई होने का मुख्य लाभ यह है कि सभी पायथन मॉड्यूल लॉगिंग में भाग ले सकते हैं, इसलिए आपके एप्लिकेशन लॉग में तीसरे पक्ष के मॉड्यूल से संदेशों के साथ एकीकृत अपने स्वयं के संदेश शामिल हो सकते हैं।

चलिए, शुरू करते हैं:

उदाहरण कॉन्फ़िगरेशन सीधे कोड में

import logging

logger = logging.getLogger()
handler = logging.StreamHandler()
formatter = logging.Formatter(
        '%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(logging.DEBUG)

logger.debug('this is a %s test', 'debug')

आउटपुट उदाहरण:

2016-07-26 18:53:55,332 root         DEBUG    this is a debug test

उदाहरण INI फ़ाइल के माध्यम से विन्यास

फ़ाइल को मान लिया गया है जिसका नाम logging_config.ini है। फ़ाइल प्रारूप के लिए अधिक विवरण लॉगिंग ट्यूटोरियल के लॉगिंग कॉन्फ़िगरेशन अनुभाग में हैं।

[loggers]
keys=root

[handlers]
keys=stream_handler

[formatters]
keys=formatter

[logger_root]
level=DEBUG
handlers=stream_handler

[handler_stream_handler]
class=StreamHandler
level=DEBUG
formatter=formatter
args=(sys.stderr,)

[formatter_formatter]
format=%(asctime)s %(name)-12s %(levelname)-8s %(message)s

फिर कोड में logging.config.fileConfig() उपयोग करें:

import logging
from logging.config import fileConfig

fileConfig('logging_config.ini')
logger = logging.getLogger()
logger.debug('often makes a very good meal of %s', 'visiting tourists')

एक शब्दकोश के माध्यम से उदाहरण विन्यास

पायथन 2.7 के रूप में, आप विन्यास विवरण के साथ एक शब्दकोश का उपयोग कर सकते हैं। PEP 391 में कॉन्फ़िगरेशन शब्दकोश में अनिवार्य और वैकल्पिक तत्वों की एक सूची है।

import logging
from logging.config import dictConfig

logging_config = dict(
    version = 1,
    formatters = {
        'f': {'format':
              '%(asctime)s %(name)-12s %(levelname)-8s %(message)s'}
        },
    handlers = {
        'h': {'class': 'logging.StreamHandler',
              'formatter': 'f',
              'level': logging.DEBUG}
        },
    root = {
        'handlers': ['h'],
        'level': logging.DEBUG,
        },
)

dictConfig(logging_config)

logger = logging.getLogger()
logger.debug('often makes a very good meal of %s', 'visiting tourists')

अपवाद लॉगिंग

यदि आप अपवादों को लॉग इन करना चाहते हैं और आपको logging.exception(msg) विधि का उपयोग करना चाहिए:

>>> import logging
>>> logging.basicConfig()
>>> try:
...     raise Exception('foo')
... except:
...     logging.exception('bar')
...
ERROR:root:bar
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
Exception: foo

तर्क के रूप में अपवाद को पास न करें:

जैसा कि logging.exception(msg) एक msg arg की अपेक्षा करता है, यह लॉगिंग कॉल में अपवाद को पास करने के लिए एक सामान्य नुकसान है:

>>> try:
...     raise Exception('foo')
... except Exception as e:
...     logging.exception(e)
...
ERROR:root:foo
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
Exception: foo

हालांकि ऐसा लग सकता है कि यह पहली बार में सही काम है, यह वास्तव में समस्या का कारण है कि लॉगिंग मॉड्यूल में अपवाद और विभिन्न एन्कोडिंग एक साथ कैसे काम करते हैं:

>>> try:
...     raise Exception(u'föö')
... except Exception as e:
...     logging.exception(e)
...
Traceback (most recent call last):
  File "/.../python2.7/logging/__init__.py", line 861, in emit
    msg = self.format(record)
  File "/.../python2.7/logging/__init__.py", line 734, in format
    return fmt.format(record)
  File "/.../python2.7/logging/__init__.py", line 469, in format
    s = self._fmt % record.__dict__
UnicodeEncodeError: 'ascii' codec can't encode characters in position 1-2: ordinal not in range(128)
Logged from file <stdin>, line 4

एक अपवाद को लॉग करने की कोशिश करना जिसमें यूनिकोड वर्ण शामिल हैं, यह तरीका बुरी तरह से विफल हो जाएगा। यह मूल अपवाद के स्टैकट्रेस को एक नए के साथ ओवरराइड करके छिपाएगा जो कि आपके logging.exception(e) कॉल के प्रारूपण के दौरान उठाया जाता है।

जाहिर है, अपने स्वयं के कोड में, आपको अपवादों में एन्कोडिंग के बारे में पता हो सकता है। हालाँकि, 3 पार्टी के पक्षकार इसे अलग तरीके से संभाल सकते हैं।

सही उपयोग:

यदि अपवाद के बजाय आप सिर्फ एक संदेश पास करते हैं और अजगर को अपना जादू करते हैं, तो यह काम करेगा:

>>> try:
...     raise Exception(u'föö')
... except Exception as e:
...     logging.exception('bar')
...
ERROR:root:bar
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
Exception: f\xf6\xf6

जैसा कि आप देख सकते हैं कि हम वास्तव में उस स्थिति में e का उपयोग नहीं करते हैं, logging.exception(...) लिए कॉल जादुई रूप से सबसे हाल के अपवादों को प्रारूपित करता है।

गैर ERROR लॉग स्तरों के साथ अपवाद लॉगिंग

यदि आप ERROR की तुलना में किसी अन्य लॉग स्तर के साथ अपवाद लॉग करना चाहते हैं, तो आप डिफ़ॉल्ट लॉग इन के exc_info तर्क का उपयोग कर सकते हैं:

logging.debug('exception occurred', exc_info=1)
logging.info('exception occurred', exc_info=1)
logging.warning('exception occurred', exc_info=1)

अपवाद के संदेश तक पहुँचना

ध्यान रखें कि किसी भी यूनिकोड या (यूएफ -8 यदि आप भाग्यशाली हैं) बाइट्स-स्ट्रिंग्स के रूप में संदेशों के साथ अपवादों को बाहर फेंक सकते हैं। यदि आपको वास्तव में अपवाद के पाठ तक पहुंचने की आवश्यकता है, तो एकमात्र विश्वसनीय तरीका, जो हमेशा काम करेगा, repr(e) या %r स्ट्रिंग प्रारूपण का उपयोग करना है:

>>> try:
...     raise Exception(u'föö')
... except Exception as e:
...     logging.exception('received this exception: %r' % e)
...
ERROR:root:received this exception: Exception(u'f\xf6\xf6',)
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
Exception: f\xf6\xf6