Django सेटअप डिफ़ॉल्ट लॉगिंग

Question

मुझे यह पता नहीं लग सकता है कि मेरे Django इंस्टॉलेशन के लिए "डिफ़ॉल्ट" लकड़हारा कैसे सेटअप किया जाए। मैं Django 1.3 की नई LOGGINGसेटिंग का उपयोग करना चाहूंगा settings.py।

मैंने Django के लॉगिंग डॉक के उदाहरण को देखा है , लेकिन यह मुझे ऐसा लगता है जैसे वे केवल सेटअप हैंडलर हैं जो लॉग लॉगर्स के लिए लॉगिंग करेंगे। अपने उदाहरण के मामले में उन्होंने 'django', 'django.request', और 'myproject.custom' नाम के लॉगर्स के लिए हैंडलर सेटअप किया।

मैं बस एक डिफ़ॉल्ट सेटअप करना चाहता हूं logging.handlers.RotatingFileHandlerजो डिफ़ॉल्ट रूप से सभी लॉगर्स को संभाल लेगा। यानी, अगर मैं अपने प्रोजेक्ट में कहीं नया मॉड्यूल बनाता हूं और इसे कुछ इस तरह से दर्शाया जाता है:, my_app_name.my_new_moduleमुझे यह करने में सक्षम होना चाहिए और सभी लॉगिंग में रोटेटिंग फ़ाइल लॉग्स होना चाहिए।

# In file './my_app_name/my_new_module.py'
import logging
logger = logging.getLogger('my_app_name.my_new_module')
logger.debug('Hello logs!') # <-- This should get logged to my RotatingFileHandler that I setup in `settings.py`!

Answer 1

पता लगा लिया...

आप इसे खाली स्ट्रिंग के साथ संदर्भित करके 'कैच ऑल' लकड़हारा सेट करें '':।

एक उदाहरण के रूप में, निम्नलिखित सेटअप में मेरे पास सभी लॉग ईवेंट हैं जो लॉग ईवेंट logs/mylog.logके अपवाद के साथ सहेजे जा रहे हैं , django.requestजिन्हें सहेजा जाएगा logs/django_request.log। क्योंकि मेरे लकड़हारे के लिए 'propagate'निर्धारित है , लॉग इवेंट कभी भी 'कैच ऑल' लकड़हारे तक नहीं पहुंचेगा।Falsedjango.request

LOGGING = {
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': {
        'standard': {
            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
        },
    },
    'handlers': {
        'default': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': 'logs/mylog.log',
            'maxBytes': 1024*1024*5, # 5 MB
            'backupCount': 5,
            'formatter':'standard',
        },  
        'request_handler': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': 'logs/django_request.log',
            'maxBytes': 1024*1024*5, # 5 MB
            'backupCount': 5,
            'formatter':'standard',
        },
    },
    'loggers': {
        '': {
            'handlers': ['default'],
            'level': 'DEBUG',
            'propagate': True
        },
        'django.request': {
            'handlers': ['request_handler'],
            'level': 'DEBUG',
            'propagate': False
        },
    }
}

Comments

क्रिस, इस पर Django डॉक्स भ्रमित नहीं कर रहे हैं। इसके लिए धन्यवाद।

छोटे सुधार: टिप्पणी का अर्थ है कि sql लॉगिंग django.request लकड़हारे से प्रभावित होगी। Sql लॉगिंग को रीडायरेक्ट करने के लिए, आप 'django.db' के लिए लकड़हारे को परिभाषित करेंगे। Django.request लकड़हारा 5xx और 4xx http प्रतिक्रियाओं को संभालता है।

— 22

इसमें मेरे जैसे अन्य नॉब्स की मदद करता है: लकड़हारा लॉग फ़ाइलों को बनाएगा, लेकिन आपको logs/पहले फ़ोल्डर बनाना होगा :-)। अन्यथा आप चलाते समय एक त्रुटि प्राप्त करेंगे ./manange.py runserver। @ क्रिस डब्ल्यू। आपके उदाहरण लॉगिंग सेटिंग्स के लिए धन्यवाद। इसने मेरी बहुत मदद की!

— hobbes3

@arindamroychowdhury उपरोक्त कॉन्फ़िगरेशन के साथ यदि आप करते हैं logger = logging.getLogger('foo'); logger.warn('bar');तो defaultहैंडलर उस लॉगिंग को पकड़ लेगा और कुछ इस तरह <time> WARN: foo: barसमाप्त हो जाएगाlogs/mylog.log

— क्रिस डब्ल्यू।

धन्यवाद ऐसा लगता है कि इस '' का अर्थ है रूट लॉगर। Django दस्तावेज़ में जानकारी का यह उपयोगी टुकड़ा नहीं मिला।

— Eino Mäkitalo

Answer 2

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

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

रूट - यह रूट लॉगर के लिए कॉन्फ़िगरेशन होगा। कॉन्फ़िगरेशन की प्रोसेसिंग किसी भी लकड़हारे के लिए होगी, सिवाय इसके कि propagateसेटिंग लागू नहीं होगी।

यहां rootकुंजी का उपयोग करने के लिए आपके उत्तर से कॉन्फ़िगरेशन बदल गया है :

LOGGING = {
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': {
        'standard': {
            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
        },
    },
    'handlers': {
        'default': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': 'logs/mylog.log',
            'maxBytes': 1024*1024*5, # 5 MB
            'backupCount': 5,
            'formatter':'standard',
        },  
        'request_handler': {
            'level':'DEBUG',
            'class':'logging.handlers.RotatingFileHandler',
            'filename': 'logs/django_request.log',
            'maxBytes': 1024*1024*5, # 5 MB
            'backupCount': 5,
            'formatter':'standard',
        },
    },
    'root': {
        'handlers': ['default'],
        'level': 'DEBUG'
    },
    'loggers': {
        'django.request': {
            'handlers': ['request_handler'],
            'level': 'DEBUG',
            'propagate': False
        },
    }
}

निष्पक्ष होने के लिए, मैं दो विन्यासों के बीच व्यवहार में कोई अंतर नहीं देख सकता। ऐसा प्रतीत होता है कि रिक्त स्ट्रिंग कुंजी के साथ एक लकड़हारे को परिभाषित करने से रूट लकड़हारा संशोधित हो logging.getLogger('')जाएगा , क्योंकि मूल लकड़हारा वापस आ जाएगा।

एकमात्र कारण मैं पसंद 'root'से अधिक ''है कि यह जड़ लकड़हारा को संशोधित करने के बारे में स्पष्ट है। यदि आप जिज्ञासु थे, तो यदि आप दोनों को परिभाषित करते हैं, तो 'root'ओवरराइड ''करता है, क्योंकि मूल प्रविष्टि अंतिम है।

Comments

हाँ, यह सही है, गर्भपात के लिए खेद है! हालांकि, 'रूट' के बजाय '' का उपयोग करना कुछ हद तक तर्कसंगत है, फिर भी मुझे उनमें से थोड़ा असंगत लगता है कि root2.6 से बेहतर फाइल की प्रक्रिया में हुकुम की जड़ में प्रवेश किया जाए।

— एंटनी हैचकिंस

Answer 3

import logging
logger = logging.getLogger(__name__)

जोड़ने के बाद:

logging.basicConfig(
    level = logging.DEBUG,
    format = '%(name)s %(levelname)s %(message)s',
)

हम इसका प्रारूप बदल सकते हैं:

format = '"%(levelname)s:%(name)s:%(message)s"  ',

या

format = '%(name)s %(asctime)s %(levelname)s %(message)s',

Answer 4

मैंने यह जांचने के लिए एक त्वरित नमूना बनाया कि क्या rootकुंजी का उपयोग किया जाता है जब दोनों कुंजी और खाली ''लकड़हारा को विन्यास में संदर्भित किया जाता है।

import logging.config

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'fmt1': {
            'format': '[FMT1] %(asctime)-15s %(message)s',
        },
        'fmt2': {
            'format': '[FMT2] %(asctime)-15s %(message)s',
        }
    },
    'handlers': {
        'console1': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'fmt1',
        },
        'console2': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'fmt2',
        },
    },
    # First config for root logger: console1 -> fmt1
    'root': {
        'handlers': ['console1'],
        'level': 'DEBUG',
        'propagate': True,
    },
    'loggers': {
        # Second config for root logger: console2 -> fmt2
        '': {
            'handlers': ['console2'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

logging.config.dictConfig(LOGGING)

l1 = logging.getLogger()
l2 = logging.getLogger('')
root = logging.root

l1.info("l1")
l2.info("l2")
root.info("root logger")

निम्नलिखित परिणाम प्रिंट करता है:

[FMT1] 2018-12-18 17:24:47,691 l1
[FMT1] 2018-12-18 17:24:47,691 l2
[FMT1] 2018-12-18 17:24:47,691 root logger

यह दर्शाता है कि rootकुंजी के तहत कॉन्फ़िगरेशन में सर्वोच्च प्राथमिकता है। यदि ब्लॉक हटा दिया जाता है, तो परिणाम है:

[FMT2] 2018-12-18 17:25:43,757 l1
[FMT2] 2018-12-18 17:25:43,757 l2
[FMT2] 2018-12-18 17:25:43,757 root logger

दोनों मामले में, मुझे डिबग और निर्धारित कि तीनों वालों (करने में सक्षम था l1, l2और root) संदर्भित एक ही लकड़हारा उदाहरण, जड़ लकड़हारा।

आशा है कि अन्य लोगों की मदद करेंगे, जो मेरे जैसे, रूट लॉगर को कॉन्फ़िगर करने के 2 अलग-अलग तरीकों से भ्रमित थे।