Django 2.1

Logging




django

Logging

एक त्वरित लॉगिंग प्राइमर

Django सिस्टम लॉगिंग करने के लिए पायथन के बिलिन logging मॉड्यूल का उपयोग करता है। इस मॉड्यूल के उपयोग के बारे में विस्तार से चर्चा पायथन के स्वयं के प्रलेखन में की गई है। हालाँकि, यदि आपने कभी पायथन लॉगिंग फ्रेमवर्क का उपयोग नहीं किया है (या यहां तक ​​कि अगर आपके पास है), तो यहां एक त्वरित प्राइमर है।

खिलाड़ियों की डाली

पायथन लॉगिंग कॉन्फ़िगरेशन में चार भाग होते हैं:

वालों

एक लकड़हारा लॉगिंग सिस्टम में प्रवेश बिंदु है। प्रत्येक लकड़हारा एक नामांकित बाल्टी है, जिस पर प्रसंस्करण के लिए संदेश लिखे जा सकते हैं।

एक लकड़हारा एक लॉग स्तर के लिए कॉन्फ़िगर किया गया है। यह लॉग स्तर उन संदेशों की गंभीरता का वर्णन करता है जो लकड़हारा संभाल लेगा। पायथन निम्नलिखित लॉग स्तरों को परिभाषित करता है:

  • DEBUG : डिबगिंग उद्देश्यों के लिए निम्न स्तर की सिस्टम जानकारी
  • INFO : सामान्य प्रणाली की जानकारी
  • WARNING : एक छोटी सी समस्या का वर्णन करने वाली जानकारी जो हुई है।
  • ERROR : एक बड़ी समस्या का वर्णन करने वाली जानकारी जो हुई है।
  • CRITICAL : एक महत्वपूर्ण समस्या का वर्णन करने वाली जानकारी।

प्रत्येक संदेश जो लकड़हारे को लिखा जाता है वह एक लॉग रिकॉर्ड है । प्रत्येक लॉग रिकॉर्ड में लॉग स्तर भी होता है जो उस विशिष्ट संदेश की गंभीरता को दर्शाता है। एक लॉग रिकॉर्ड में उपयोगी मेटाडेटा भी हो सकता है जो लॉग होने वाली घटना का वर्णन करता है। इसमें स्टैक ट्रेस या त्रुटि कोड जैसे विवरण शामिल हो सकते हैं।

जब संदेश लकड़हारे को दिया जाता है, तो संदेश के लॉग स्तर की तुलना लकड़हारे के लॉग स्तर से की जाती है। यदि संदेश का लॉग स्तर लॉगगर के लॉग स्तर से मिलता है या उससे अधिक है, तो संदेश आगे की प्रक्रिया से गुजरना होगा। यदि ऐसा नहीं होता है, तो संदेश को नजरअंदाज कर दिया जाएगा।

एक बार एक लकड़हारा निर्धारित करता है कि एक संदेश को संसाधित करने की आवश्यकता है, यह एक हैंडलर को दिया जाता है।

हैंडलर

हैंडलर वह इंजन है जो यह निर्धारित करता है कि लकड़हारे के प्रत्येक संदेश का क्या होता है। यह एक विशेष लॉगिंग व्यवहार का वर्णन करता है, जैसे स्क्रीन पर एक संदेश लिखना, एक फ़ाइल, या एक नेटवर्क सॉकेट के लिए।

लॉगर की तरह, हैंडलर का भी एक लॉग स्तर होता है। यदि लॉग रिकॉर्ड का लॉग स्तर हैंडलर के स्तर से अधिक या पूरा नहीं होता है, तो हैंडलर संदेश को अनदेखा कर देगा।

एक लॉगर में कई हैंडलर हो सकते हैं, और प्रत्येक हैंडलर का एक अलग लॉग स्तर हो सकता है। इस तरह, एक संदेश के महत्व के आधार पर अधिसूचना के विभिन्न रूपों को प्रदान करना संभव है। उदाहरण के लिए, आप एक हैंडलर स्थापित कर सकते हैं जो पेजर सेवा के लिए ERROR और CRITICAL संदेशों को अग्रेषित करता है, जबकि दूसरा हैंडलर बाद के विश्लेषण के लिए सभी संदेशों ( ERROR और CRITICAL संदेशों सहित) को एक फ़ाइल में लॉग करता है।

फिल्टर

एक फ़िल्टर का उपयोग अतिरिक्त नियंत्रण प्रदान करने के लिए किया जाता है, जिस पर लॉग रिकॉर्ड को लकड़हारा से हैंडलर में पारित किया जाता है।

डिफ़ॉल्ट रूप से, लॉग स्तर की आवश्यकताओं को पूरा करने वाले किसी भी लॉग संदेश को संभाला जाएगा। हालाँकि, फ़िल्टर स्थापित करके, आप लॉगिंग प्रक्रिया पर अतिरिक्त मानदंड स्थापित कर सकते हैं। उदाहरण के लिए, आप एक फ़िल्टर स्थापित कर सकते हैं जो केवल ERROR संदेशों को किसी विशेष स्रोत से उत्सर्जित करने की अनुमति देता है।

फ़िल्टर का उपयोग उत्सर्जित होने से पहले लॉगिंग रिकॉर्ड को संशोधित करने के लिए भी किया जा सकता है। उदाहरण के लिए, आप एक ऐसा फ़िल्टर लिख सकते हैं, जो मानदंड के एक विशेष सेट को पूरा करने के लिए ERROR लॉग रिकॉर्ड को डाउनग्रेड कर देता है।

फ़िल्टर लॉगर या हैंडलर पर स्थापित किए जा सकते हैं; कई फ़िल्टरिंग क्रियाओं को करने के लिए एक श्रृंखला में कई फ़िल्टर का उपयोग किया जा सकता है।

formatters

अंततः, एक लॉग रिकॉर्ड को पाठ के रूप में प्रस्तुत करना होगा। प्रारूपकार उस पाठ के सटीक प्रारूप का वर्णन करते हैं। एक फॉर्मैटर में आमतौर पर एक लॉगऑनकार्ड विशेषताओं वाले पायथन प्रारूपण स्ट्रिंग होते हैं; हालाँकि, आप विशिष्ट स्वरूपण व्यवहार को लागू करने के लिए कस्टम स्वरूपण भी लिख सकते हैं।

लॉगिंग का उपयोग करना

एक बार जब आप अपने लॉगर, हैंडलर, फिल्टर और फॉर्मेटर्स कॉन्फ़िगर कर लेते हैं, तो आपको लॉगिंग कॉल को अपने कोड में रखना होगा। लॉगिंग फ्रेमवर्क का उपयोग करना बहुत सरल है। यहाँ एक उदाहरण है:

# import the logging library
import logging

# Get an instance of a logger
logger = logging.getLogger(__name__)

def my_view(request, arg1, arg):
    ...
    if bad_mojo:
        # Log an error message
        logger.error('Something went wrong!')

और बस! हर बार जब bad_mojo स्थिति सक्रिय हो जाती है, तो एक त्रुटि लॉग रिकॉर्ड लिखा जाएगा।

नामकरण करने वाले

logging.getLogger() लिए कॉल एक लकड़हारा का एक उदाहरण (यदि आवश्यक हो, तो logging.getLogger() प्राप्त करता है। लकड़हारा उदाहरण एक नाम से पहचाना जाता है। यह नाम कॉन्फ़िगरेशन उद्देश्यों के लिए लकड़हारे की पहचान करने के लिए उपयोग किया जाता है।

सम्मेलन द्वारा, लकड़हारा का नाम आमतौर पर __name__ , अजगर अजगर का नाम जिसमें लकड़हारा होता है। यह आपको प्रति-मॉड्यूल आधार पर लॉगिंग कॉल को फ़िल्टर करने और संभालने की अनुमति देता है। हालाँकि, यदि आपके पास अपने लॉगिंग संदेशों को व्यवस्थित करने का कोई अन्य तरीका है, तो आप अपने लकड़हारे की पहचान करने के लिए कोई भी अलग-अलग नाम प्रदान कर सकते हैं:

# Get an instance of a specific named logger
logger = logging.getLogger('project.interesting.stuff')

लकड़हारा नामों के बिंदीदार पथ एक पदानुक्रम को परिभाषित करते हैं। project.interesting लकड़हारा project.interesting लकड़हारा का जनक माना जाता है; project लकड़हारा project का एक जनक है। लकड़हारा लकड़हारा।

पदानुक्रम क्यों महत्वपूर्ण है? ठीक है, क्योंकि लकड़हारे अपने माता-पिता को अपने लॉगिंग कॉल को प्रचारित करने के लिए सेट कर सकते हैं। इस तरह, आप एक लकड़हारा पेड़ की जड़ में हैंडलर के एक सेट को परिभाषित कर सकते हैं, और लॉगर के सबट्री में सभी लॉगिंग कॉल को पकड़ सकते हैं। project नेमस्पेस में परिभाषित एक लॉगिंग हैंडलर, project.interesting और project.interesting.stuff लॉगर पर जारी किए गए सभी लॉगिंग संदेशों को पकड़ लेगा।

इस प्रसार को प्रति लकड़हारा आधार पर नियंत्रित किया जा सकता है। यदि आप किसी विशेष लकड़हारे को उसके माता-पिता के सामने प्रचारित नहीं करना चाहते हैं, तो आप इस व्यवहार को बंद कर सकते हैं।

लॉगिंग कॉल करना

लकड़हारा उदाहरण में डिफ़ॉल्ट लॉग स्तरों में से प्रत्येक के लिए एक प्रवेश विधि है:

  • logger.debug()
  • logger.info()
  • logger.warning()
  • logger.error()
  • logger.critical()

दो अन्य लॉगिंग कॉल उपलब्ध हैं:

  • logger.log() : मैन्युअल रूप से एक लॉगिंग संदेश को विशिष्ट लॉग स्तर के साथ उत्सर्जित करता है।
  • logger.exception() : एक ERROR स्तर लॉगिंग संदेश बनाता है जो वर्तमान अपवाद स्टैक फ़्रेम को लपेटता है।

लॉगिंग कॉन्फ़िगर करना

बेशक, यह केवल आपके कोड में लॉगिंग कॉल डालने के लिए पर्याप्त नहीं है। आपको यह सुनिश्चित करने के लिए भी लॉगर्स, हैंडलर, फिल्टर और फॉर्मेटर्स को कॉन्फ़िगर करने की आवश्यकता है कि लॉगिंग आउटपुट उपयोगी तरीके से आउटपुट है।

पायथन की लॉगिंग लाइब्रेरी लॉगिंग को कॉन्फ़िगर करने के लिए कई तकनीकों को प्रदान करती है, जिसमें प्रोग्रामेटिक इंटरफ़ेस से लेकर कॉन्फ़िगरेशन फ़ाइलों तक शामिल है। डिफ़ॉल्ट रूप से, Django तानाशाही प्रारूप का उपयोग करता है।

लॉगिंग को कॉन्फ़िगर करने के लिए, आप LOGGING सेटिंग्स के डिक्शनरी को परिभाषित करने के लिए लॉगिंग का उपयोग करते हैं। ये सेटिंग्स लॉगर्स, हैंडलर, फिल्टर और फॉर्मेटर्स का वर्णन करती हैं जो आप अपने लॉगिंग सेटअप में चाहते हैं, और लॉग स्तर और अन्य गुण जो आप चाहते हैं कि वे घटक हैं।

डिफ़ॉल्ट रूप से, लॉगिंग सेटिंग को निम्न योजना का उपयोग करके Django के डिफ़ॉल्ट लॉगिंग कॉन्फ़िगरेशन के साथ विलय कर दिया जाता है।

यदि LOGGING डिक्टॉन्फ़िग में disable_existing_loggers कुंजी True (जो कि डिफ़ॉल्ट है) पर सेट है, तो डिफ़ॉल्ट कॉन्फ़िगरेशन से सभी लॉगर अक्षम हो जाएंगे। अक्षम किए गए लॉगर हटाए गए समान नहीं हैं; लकड़हारा अभी भी मौजूद रहेगा, लेकिन चुपचाप इसमें लॉग की गई किसी भी चीज को छोड़ देगा, यहां तक ​​कि माता-पिता के लकड़हारे को भी प्रविष्टियों का प्रचार नहीं करना। इस प्रकार आपको 'disable_existing_loggers': True का उपयोग करके बहुत सावधान रहना चाहिए 'disable_existing_loggers': True ; यह शायद वह नहीं है जो आप चाहते हैं। इसके बजाय, आप disable_existing_loggers को कुछ या सभी डिफ़ॉल्ट लॉगर को False और फिर से परिभाषित करने के लिए सेट कर सकते हैं; या आप LOGGING_CONFIG को None को None सेट None कर सकते हैं और लॉगिंग LOGGING_CONFIG को स्वयं संभाल सकते हैं

लॉगिंग को सामान्य Django setup() फ़ंक्शन के भाग के रूप में कॉन्फ़िगर किया गया है। इसलिए, आप निश्चित हो सकते हैं कि लॉगर आपके प्रोजेक्ट कोड में उपयोग के लिए हमेशा तैयार हैं।

उदाहरण

तानाशाही प्रारूप के लिए पूर्ण प्रलेखन लॉगिंग कॉन्फ़िगरेशन शब्दकोशों के बारे में जानकारी का सबसे अच्छा स्रोत है। हालांकि, जो संभव है उसका स्वाद देने के लिए, यहां कई उदाहरण हैं।

सबसे पहले, यहाँ एक सरल विन्यास है जो django लकड़हारे से एक स्थानीय फ़ाइल में सभी लॉगिंग लिखता है:

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': '/path/to/django/debug.log',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

यदि आप इस उदाहरण का उपयोग करते हैं, तो 'filename' पथ को उस स्थान पर बदलना सुनिश्चित करें जो उपयोगकर्ता के द्वारा लिखने योग्य है जो Django एप्लिकेशन चला रहा है।

दूसरा, यहां एक उदाहरण है कि लॉगिंग सिस्टम को बनाने के लिए कैसे Django के लॉगिंग को कंसोल पर प्रिंट करें। यह स्थानीय विकास के दौरान उपयोगी हो सकता है।

डिफ़ॉल्ट रूप से, यह कॉन्फ़िगरेशन केवल INFO या उच्च स्तर के संदेश भेजता है (जो Django के डिफ़ॉल्ट लॉगिंग कॉन्फ़िगरेशन के समान है, सिवाय इसके कि डिफ़ॉल्ट केवल लॉग रिकॉर्ड प्रदर्शित करता है जब DEBUG=True )। Django ऐसे कई संदेशों को लॉग नहीं करता है। इस कॉन्फ़िगरेशन के साथ, आप Django के सभी डिबग लॉगिंग को देखने के लिए पर्यावरण चर DJANGO_LOG_LEVEL=DEBUG भी सेट कर सकते हैं जो बहुत ही क्रियात्मक है क्योंकि इसमें सभी डेटाबेस क्वेरी शामिल हैं:

import os

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console': {
            'class': 'logging.StreamHandler',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['console'],
            'level': os.getenv('DJANGO_LOG_LEVEL', 'INFO'),
        },
    },
}

अंत में, यहाँ एक काफी जटिल लॉगिंग सेटअप का एक उदाहरण है:

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'verbose': {
            'format': '{levelname} {asctime} {module} {process:d} {thread:d} {message}',
            'style': '{',
        },
        'simple': {
            'format': '{levelname} {message}',
            'style': '{',
        },
    },
    'filters': {
        'special': {
            '()': 'project.logging.SpecialFilter',
            'foo': 'bar',
        },
        'require_debug_true': {
            '()': 'django.utils.log.RequireDebugTrue',
        },
    },
    'handlers': {
        'console': {
            'level': 'INFO',
            'filters': ['require_debug_true'],
            'class': 'logging.StreamHandler',
            'formatter': 'simple'
        },
        'mail_admins': {
            'level': 'ERROR',
            'class': 'django.utils.log.AdminEmailHandler',
            'filters': ['special']
        }
    },
    'loggers': {
        'django': {
            'handlers': ['console'],
            'propagate': True,
        },
        'django.request': {
            'handlers': ['mail_admins'],
            'level': 'ERROR',
            'propagate': False,
        },
        'myproject.custom': {
            'handlers': ['console', 'mail_admins'],
            'level': 'INFO',
            'filters': ['special']
        }
    }
}

यह लॉगिंग कॉन्फ़िगरेशन निम्न चीज़ें करता है:

  • 'तानाशाही संस्करण 1' प्रारूप में होने के रूप में विन्यास की पहचान करता है। वर्तमान में, यह केवल तानाशाही प्रारूप संस्करण है।
  • दो स्वरूपकों को परिभाषित करता है:

    • simple , कि बस लॉग स्तर नाम (जैसे, DEBUG ) और लॉग संदेश आउटपुट।

      format स्ट्रिंग एक सामान्य पायथन प्रारूपण स्ट्रिंग है जो विवरणों का वर्णन करता है जो प्रत्येक लॉगिंग लाइन पर आउटपुट होते हैं। विवरण की पूरी सूची जो आउटपुट हो सकती है वह फॉर्मैटर ऑब्जेक्ट्स में पाई जा सकती है।

    • verbose , जो लॉग स्तर नाम, लॉग संदेश और साथ ही लॉग संदेश उत्पन्न करने वाले समय, प्रक्रिया, थ्रेड और मॉड्यूल को आउटपुट करता है।
  • दो फिल्टर परिभाषित करता है:

    • project.logging.SpecialFilter , उपनाम special का उपयोग करके। यदि इस फ़िल्टर को अतिरिक्त तर्क की आवश्यकता होती है, तो उन्हें फ़िल्टर कॉन्फ़िगरेशन डिक्शनरी में अतिरिक्त कुंजी के रूप में प्रदान किया जा सकता है। इस मामले में, तर्क foo को SpecialFilter करते समय bar मान दिया जाएगा।
    • django.utils.log.RequireDebugTrue , जो DEBUG के True होने पर अभिलेखों से गुजरता है।
  • दो संचालकों को परिभाषित करता है:

    • console , एक StreamHandler , जो किसी भी INFO (या उच्चतर) संदेश को sys.stderr पर sys.stderr । यह हैंडलर simple आउटपुट प्रारूप का उपयोग करता है।
    • mail_admins , एक AdminEmailHandler , जो ADMINS साइट पर किसी भी ERROR (या उच्चतर) संदेश को ADMINS । यह हैंडलर special फिल्टर का उपयोग करता है।
  • तीन लोगों को कॉन्फ़िगर करता है:

    • django , जो सभी संदेश console हैंडलर को देता है।
    • django.request , जो सभी ERROR संदेशों को mail_admins हैंडलर में mail_admins । इसके अलावा, यह लकड़हारा संदेशों को प्रचारित नहीं करने के लिए चिह्नित है। इसका अर्थ है कि django.request को लिखे गए लॉग संदेश django django.request द्वारा नियंत्रित नहीं किए जाएंगे।
    • myproject.custom , जो INFO या उच्चतर सभी संदेशों को पास करता है जो special फ़िल्टर को दो हैंडलर - console और mail_admins को भी पास करते हैं। इसका अर्थ है कि सभी INFO स्तर के संदेश (या उच्चतर) कंसोल पर मुद्रित होंगे; ईमेल के माध्यम से ERROR और CRITICAL संदेश भी आउटपुट होंगे।

कस्टम लॉगिंग कॉन्फ़िगरेशन

यदि आप अपने लकड़हारे को कॉन्फ़िगर करने के लिए अजगर के तानाशाह प्रारूप का उपयोग नहीं करना चाहते हैं, तो आप अपनी कॉन्फ़िगरेशन योजना को निर्दिष्ट कर सकते हैं।

LOGGING_CONFIG सेटिंग उस LOGGING_CONFIG करने योग्य को परिभाषित करती है जिसका उपयोग Django के लॉगर को कॉन्फ़िगर करने के लिए किया जाएगा। डिफ़ॉल्ट रूप से, यह पायथन के logging.config.dictConfig() पर इंगित करता है logging.config.dictConfig() फ़ंक्शन। हालाँकि, यदि आप किसी भिन्न कॉन्फ़िगरेशन प्रक्रिया का उपयोग करना चाहते हैं, तो आप किसी अन्य कॉल करने योग्य का उपयोग कर सकते हैं जो एकल तर्क लेता है। लॉगिंग को कॉन्फ़िगर करते समय लॉगिंग की सामग्री को उस तर्क के मूल्य के रूप में प्रदान किया जाएगा।

लॉगिंग कॉन्फ़िगरेशन को अक्षम करना

यदि आप लॉगिंग को सभी में कॉन्फ़िगर नहीं करना चाहते हैं (या आप स्वयं अपने दृष्टिकोण का उपयोग करके लॉगिंग को कॉन्फ़िगर करना चाहते हैं), तो आप LOGGING_CONFIG को None सेट None कर सकते। यह Django के डिफ़ॉल्ट लॉगिंग के लिए कॉन्फ़िगरेशन प्रक्रिया को अक्षम कर देगा। यहाँ एक उदाहरण है जो Django के लॉगिंग कॉन्फ़िगरेशन को अक्षम करता है और फिर मैन्युअल रूप से लॉगिंग को कॉन्फ़िगर करता है:

LOGGING_CONFIG = None

import logging.config
logging.config.dictConfig(...)

LOGGING_CONFIG को None सेट करने का अर्थ केवल यह None है कि स्वचालित कॉन्फ़िगरेशन प्रक्रिया अक्षम है, स्वयं लॉगिंग नहीं। यदि आप कॉन्फ़िगरेशन प्रक्रिया को अक्षम करते हैं, तो Django अभी भी लॉगिंग कॉल करेगा, जो भी डिफ़ॉल्ट लॉगिंग व्यवहार को परिभाषित किया गया है वह वापस गिर जाएगा।

Django के लॉगिंग एक्सटेंशन

Django वेब सर्वर वातावरण में लॉगिंग की अनूठी आवश्यकताओं को संभालने के लिए कई उपयोगिताओं को प्रदान करता है।

वालों

Django कई निर्मित लॉगर प्रदान करता है।

django

django पदानुक्रम में संदेशों के लिए सभी लकड़हारा। इस नाम का उपयोग करके कोई संदेश पोस्ट नहीं किया गया है, बल्कि नीचे दिए गए लॉगर्स में से एक का उपयोग कर रहे हैं।

django.request

अनुरोध से निपटने से संबंधित संदेश लॉग करें। 5XX प्रतिक्रियाओं को ERROR संदेशों के रूप में उठाया जाता है; 4XX प्रतिक्रियाओं को WARNING संदेशों के रूप में उठाया जाता है। django.security के django.security लॉग किए गए django.request लॉग नहीं किए django.request

इस लकड़हारे के संदेशों में निम्नलिखित अतिरिक्त संदर्भ हैं:

  • status_code : HTTP प्रतिक्रिया कोड अनुरोध के साथ जुड़ा हुआ है।
  • request : अनुरोध वस्तु जो लॉगिंग संदेश उत्पन्न करती है।

django.server

runserver कमांड द्वारा आमंत्रित सर्वर द्वारा प्राप्त अनुरोधों से निपटने से संबंधित संदेश लॉग करें। HTTP 5XX प्रतिक्रियाओं को ERROR संदेशों के रूप में लॉग किया जाता है, 4XX प्रतिक्रियाओं को लॉगिंग संदेशों के रूप में लॉग किया जाता है, और बाकी सब कुछ INFO रूप में लॉग किया जाता है।

इस लकड़हारे के संदेशों में निम्नलिखित अतिरिक्त संदर्भ हैं:

  • status_code : HTTP प्रतिक्रिया कोड अनुरोध के साथ जुड़ा हुआ है।
  • request : अनुरोध वस्तु जो लॉगिंग संदेश उत्पन्न करती है।

django.template

टेम्प्लेट के प्रतिपादन से संबंधित संदेश लॉग करें।

  • अनुपलब्ध संदर्भ चर को DEBUG संदेशों के रूप में लॉग किया जाता है।

django.db.backends

डेटाबेस के साथ कोड की बातचीत से संबंधित संदेश। उदाहरण के लिए, अनुरोध द्वारा निष्पादित प्रत्येक एप्लिकेशन-स्तरीय SQL स्टेटमेंट इस DEBUG लिए DEBUG स्तर पर लॉग इन किया जाता है।

इस लकड़हारे के संदेशों में निम्नलिखित अतिरिक्त संदर्भ हैं:

  • duration : एसक्यूएल स्टेटमेंट को निष्पादित करने में लगने वाला समय।
  • sql : SQL कथन जिसे निष्पादित किया गया था।
  • params : SQL कॉल में उपयोग किए गए पैरामीटर।

प्रदर्शन कारणों के लिए, SQL लॉगिंग केवल तभी सक्षम की जाती है जब settings.DEBUG सही पर सेट होता है, भले ही लॉगिंग स्तर या हैंडलर स्थापित हो।

इस लॉगिंग में फ्रेम-लेवल इनिशियलाइज़ेशन (जैसे SET TIMEZONE ) या ट्रांज़ेक्शन मैनेजमेंट क्वेश्चन (जैसे BEGIN , COMMIT और ROLLBACK ) शामिल नहीं हैं। यदि आप सभी डेटाबेस प्रश्नों को देखना चाहते हैं, तो अपने डेटाबेस में क्वेरी लॉगिंग चालू करें।

django.security.*

SuspiciousOperation और अन्य सुरक्षा संबंधी त्रुटियों पर सुरक्षा लॉगर्स को संदेश प्राप्त होगा। सभी SuspiciousOperation एस सहित सुरक्षा त्रुटि के प्रत्येक उपप्रकार के लिए एक उप-लकड़हारा है। लॉग ईवेंट का स्तर इस बात पर निर्भर करता है कि अपवाद को कहां हैंडल किया गया है। अधिकांश घटनाओं को चेतावनी के रूप में लॉग किया जाता है, जबकि WSGI हैंडलर तक पहुंचने वाले किसी भी SuspiciousOperation त्रुटि के रूप में लॉग किया जाएगा। उदाहरण के लिए, जब HTTP Host हेडर एक ग्राहक से अनुरोध में शामिल होता है जो ALLOWED_HOSTS मेल नहीं खाता है, तो Django 400 प्रतिक्रिया लौटाएगा, और एक त्रुटि संदेश django.security.DisallowedHost से लॉग इन किया जाएगा।

ये लॉग ईवेंट डिफ़ॉल्ट रूप से django लॉगर तक पहुंच जाएगा, जो DEBUG=False होने पर प्रवेश के लिए त्रुटि घटनाओं को मेल करता है। एक SuspiciousOperation django.request कारण 400 प्रतिक्रिया में परिणाम अनुरोध django.request लिए लॉग इन नहीं किया जाएगा, लेकिन केवल django.security लकड़हारा करने के लिए।

किसी विशेष प्रकार के SuspiciousOperation को चुप करने के लिए, आप इस उदाहरण के बाद उस विशिष्ट लकड़हारे को ओवरराइड कर सकते हैं:

'handlers': {
    'null': {
        'class': 'logging.NullHandler',
    },
},
'loggers': {
    'django.security.DisallowedHost': {
        'handlers': ['null'],
        'propagate': False,
    },
},

अन्य django.security लकड़हारा SuspiciousOperation आधार पर नहीं हैं:

django.db.backends.schema

SQL क्वेरीज़ को स्कीमा परिवर्तन के दौरान निष्पादित किया जाता है जो डेटाबेस में माइग्रेशन फ्रेमवर्क द्वारा परिवर्तन करता है। ध्यान दें कि यह RunPython द्वारा निष्पादित प्रश्नों को लॉग नहीं करेगा। इस django.db.backends को संदेश उनके अतिरिक्त संदर्भ में (और django.db.backends विपरीत है, अवधि नहीं है) django.db.backends और sql । मानों का वही अर्थ है जो django.db.backends में बताया गया है।

हैंडलर

Django पायथन लॉगिंग मॉड्यूल द्वारा प्रदान किए गए लोगों के अलावा एक लॉग हैंडलर प्रदान करता है।

class AdminEmailHandler(include_html=False, email_backend=None) [source]

यह हैंडलर प्रत्येक प्राप्त होने वाले लॉग संदेश के लिए ADMINS साइट पर एक ईमेल भेजता है।

यदि लॉग रिकॉर्ड में एक request विशेषता होती है, तो request का पूरा विवरण ईमेल में शामिल किया जाएगा। ईमेल विषय में वाक्यांश "आंतरिक आईपी" शामिल होगा यदि ग्राहक का आईपी पता INTERNAL_IPS सेटिंग में है; यदि नहीं, तो इसमें "बाहरी आईपी" शामिल होगा।

यदि लॉग रिकॉर्ड में स्टैक ट्रेस जानकारी है, तो स्टैक ट्रेस को ईमेल में शामिल किया जाएगा।

AdminEmailHandler के AdminEmailHandler तर्क को नियंत्रित करने के लिए उपयोग किया जाता है कि क्या ट्रेसबैक ईमेल में डीबग वेब पेज की पूर्ण सामग्री वाले HTML अनुलग्नक शामिल हैं जो कि DEBUG True निर्मित होते। अपने कॉन्फ़िगरेशन में यह मान सेट करने के लिए, इसे django.utils.log.AdminEmailHandler लिए हैंडलर परिभाषा में शामिल करें:

'handlers': {
    'mail_admins': {
        'level': 'ERROR',
        'class': 'django.utils.log.AdminEmailHandler',
        'include_html': True,
    }
},

ध्यान दें कि ईमेल के इस HTML संस्करण में स्टैक के प्रत्येक स्तर पर स्थानीय चर के नाम और मूल्यों के साथ एक पूर्ण ट्रेसबैक शामिल है, साथ ही आपकी Django सेटिंग्स का मान भी। यह जानकारी संभावित रूप से बहुत संवेदनशील है, और आप इसे ईमेल पर नहीं भेजना चाहते हैं। दोनों दुनिया के सर्वश्रेष्ठ प्राप्त करने के लिए Sentry जैसे कुछ का उपयोग करने पर विचार करें - पूर्ण ट्रेसबैक की समृद्ध जानकारी और ईमेल के माध्यम से जानकारी नहीं भेजने की सुरक्षा। आप त्रुटि रिपोर्ट को फ़िल्टर करने के लिए स्पष्ट रूप से कुछ संवेदनशील जानकारी निर्दिष्ट कर सकते हैं - फ़िल्टरिंग त्रुटि रिपोर्ट पर अधिक जानें।

email_backend के email_backend तर्क को AdminEmailHandler करके, हैंडलर द्वारा उपयोग किए जा रहे ईमेल बैकएंड को ओवरराइड किया जा सकता है, जैसे:

'handlers': {
    'mail_admins': {
        'level': 'ERROR',
        'class': 'django.utils.log.AdminEmailHandler',
        'email_backend': 'django.core.mail.backends.filebased.EmailBackend',
    }
},

डिफ़ॉल्ट रूप से, EMAIL_BACKEND में निर्दिष्ट ईमेल बैकएंड का एक उदाहरण उपयोग किया जाएगा।

send_mail(subject, message, *args, **kwargs) [source]

उपयोगकर्ताओं को व्यवस्थापक करने के लिए ईमेल भेजता है। इस व्यवहार को अनुकूलित करने के लिए, आप AdminEmailHandler वर्ग को उप-वर्ग कर सकते हैं और इस पद्धति को ओवरराइड कर सकते हैं।

फिल्टर

Django पायथन लॉगिंग मॉड्यूल द्वारा प्रदान किए गए लोगों के अलावा कुछ लॉग फिल्टर प्रदान करता है।

class CallbackFilter(callback) [source]

यह फ़िल्टर एक कॉलबैक फ़ंक्शन (जिसे एकल तर्क को स्वीकार करना चाहिए, लॉग करने के लिए रिकॉर्ड होना चाहिए) को स्वीकार करता है, और फ़िल्टर के माध्यम से गुजरने वाले प्रत्येक रिकॉर्ड के लिए कॉल करता है। कॉलबैक के गलत होने पर उस रिकॉर्ड की हैंडलिंग आगे नहीं बढ़ेगी।

उदाहरण के लिए, UnreadablePostError (जब कोई उपयोगकर्ता अपलोड को रद्द करता है) को एडमिन ईमेल से फ़िल्टर करने के लिए, आप एक फ़िल्टर फ़ंक्शन बनाएंगे:

from django.http import UnreadablePostError

def skip_unreadable_post(record):
    if record.exc_info:
        exc_type, exc_value = record.exc_info[:2]
        if isinstance(exc_value, UnreadablePostError):
            return False
    return True

और फिर इसे अपने लॉगिंग कॉन्फ़िगरेशन में जोड़ें:

'filters': {
    'skip_unreadable_posts': {
        '()': 'django.utils.log.CallbackFilter',
        'callback': skip_unreadable_post,
    }
},
'handlers': {
    'mail_admins': {
        'level': 'ERROR',
        'filters': ['skip_unreadable_posts'],
        'class': 'django.utils.log.AdminEmailHandler'
    }
},
class RequireDebugFalse [source]

यह फ़िल्टर केवल अभिलेखों पर ही पास होगा जब settings.DEBUG गलत है।

इस फ़िल्टर का उपयोग डिफ़ॉल्ट LOGGING कॉन्फ़िगरेशन में निम्नानुसार किया जाता है ताकि यह सुनिश्चित हो सके कि AdminEmailHandler के AdminEmailHandler पर AdminEmailHandler केवल व्यवस्थापक को त्रुटि ईमेल भेजता है:

'filters': {
    'require_debug_false': {
        '()': 'django.utils.log.RequireDebugFalse',
    }
},
'handlers': {
    'mail_admins': {
        'level': 'ERROR',
        'filters': ['require_debug_false'],
        'class': 'django.utils.log.AdminEmailHandler'
    }
},
class RequireDebugTrue [source]

यह फ़िल्टर आवश्यकताएँ RequireDebugFalse समान है, सिवाय इसके कि अभिलेख केवल तब पारित किए जाते हैं जब DEBUG True

Django के डिफ़ॉल्ट लॉगिंग कॉन्फ़िगरेशन

डिफ़ॉल्ट रूप से, Django निम्नलिखित लॉगिंग को कॉन्फ़िगर करता है:

जब DEBUG True :

  • django लकड़हारा django hierarchy ( django.server को छोड़कर) में INFO स्तर या कंसोल पर उच्च पर संदेश भेजता है।

जब DEBUG False :

  • django लकड़हारा django hierarchy ( django.server को छोड़कर) में ERROR या CRITICAL स्तर के साथ AdminEmailHandler को AdminEmailHandler

DEBUG के मूल्य का स्वतंत्र:

  • django.server लकड़हारा INFO स्तर पर या उच्चतर कंसोल को संदेश भेजता है।

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