Logging.config.dictConfig का पूरा उदाहरण कहां है?

Question

मैं डिक्टोनफिग का उपयोग करना चाहूंगा , लेकिन प्रलेखन थोड़ा सार है। मुझे जिस शब्दकोश का उपयोग करना है उसका एक ठोस, कॉपी + पेस्ट-सक्षम उदाहरण कहां मिल सकता है dictConfig?

Answer 1

यहाँ कैसे!

LOGGING_CONFIG = { 
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': { 
        'standard': { 
            'format': '%(asctime)s [%(levelname)s] %(name)s: %(message)s'
        },
    },
    'handlers': { 
        'default': { 
            'level': 'INFO',
            'formatter': 'standard',
            'class': 'logging.StreamHandler',
            'stream': 'ext://sys.stdout',  # Default is stderr
        },
    },
    'loggers': { 
        '': {  # root logger
            'handlers': ['default'],
            'level': 'WARNING',
            'propagate': False
        },
        'my.packg': { 
            'handlers': ['default'],
            'level': 'INFO',
            'propagate': False
        },
        '__main__': {  # if __name__ == '__main__'
            'handlers': ['default'],
            'level': 'DEBUG',
            'propagate': False
        },
    } 
}

उपयोग:

# Run once at startup:
logging.config.dictConfig(LOGGING_CONFIG)

# Include in each module:
log = logging.getLogger(__name__)
log.debug("Logging is configured.")

यदि आप तृतीय-पक्ष पैकेज से बहुत अधिक लॉग देखते हैं, तो तृतीय-पक्ष पैकेज आयात logging.config.dictConfig(LOGGING_CONFIG) होने से पहले इस कॉन्फ़िगरेशन को चलाना सुनिश्चित करें ।

संदर्भ: https://docs.python.org/3/library/log.config.html#configuration-dEDIA-schaa

Comments

लकड़हारे को निर्दिष्ट करने के लिए एक वैकल्पिक स्थान है root: शब्दकोश के शीर्ष स्तर पर। यह डॉक्स में वर्णित है , ['loggers']['']दोनों के मौजूद होने पर वरीयता है , लेकिन मेरी राय में, ['loggers']['']अधिक तार्किक है। यहाँ

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

उन सभी संक्षिप्त, अजगर लॉगिंग में सुंदर YAML स्निपेट्स। बस सीधे नहीं पढ़े जा सकते हैं। ओह।

— जिमब मेव

यह django- विशिष्ट नहीं है? क्या होगा अगर मैं एक अलग रूपरेखा (फ्लास्क, बोतल, आदि) का उपयोग कर रहा हूं, या वेब एप्लिकेशन पर भी काम नहीं कर रहा हूं?

— एडम पार्किन

ऐसा लगता है 'disable_existing_loggers': Falseकि तब के साथ एक धोखा है क्योंकि आप शायद इसे पूरे कपड़े को कॉन्फ़िगर नहीं कर रहे हैं, लेकिन शायद कुछ ऐसा है जो पहले से ही है। यदि आप इसे सेट करते हैं Trueतो मुझे कोई आउटपुट नहीं मिलता है।

— निक टी।

हाय @Dave, मैं कैसे पर एक कस्टम वर्ग का उपयोग कर सकते formatसे formatters?

— राफा आइकोली

Answer 2

स्वीकृत उत्तर अच्छा है! लेकिन क्या होगा अगर कोई कुछ कम जटिल के साथ शुरू कर सकता है? लॉगिंग मॉड्यूल बहुत शक्तिशाली चीज है और विशेष रूप से नौसिखिए के लिए प्रलेखन थोड़ा भारी है। लेकिन शुरुआत के लिए आपको फ़ॉर्मेटर्स और हैंडलर कॉन्फ़िगर करने की कोई आवश्यकता नहीं है। आप जब चाहें इसका पता लगा सकते हैं।

उदाहरण के लिए:

import logging.config

DEFAULT_LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'loggers': {
        '': {
            'level': 'INFO',
        },
        'another.module': {
            'level': 'DEBUG',
        },
    }
}

logging.config.dictConfig(DEFAULT_LOGGING)

logging.info('Hello, log')

Comments

यह अधिक प्रासंगिक / उपयोगी उदाहरण है, कम से कम मेरे मामले में। यह अंतिम था logging.info('Hello, log')जिसने चीजों को मेरे लिए क्लिक किया। प्रलेखन में भ्रम की स्थिति यह है कि डिक्टेंकफिग के साथ हमें अब getLoggerउन क्रियाओं को करने या करने की आवश्यकता नहीं है ।

— माइक विलियमसन

@ क्या आप खाली कुंजी को समझा सकते हैं '': { 'level': 'INFO'...और इसके बिना काम क्यों नहीं कर सकते (जैसे जब खाली मान को मान्य मान में standard

— बदलना

@MikeWilliamson: यह उपयोगी हो सकता है, हालांकि, getLogger()अगर आप अलग-अलग नामों के साथ कई लॉगर चाहते हैं, तब भी कॉल कर सकते हैं। इनमें से प्रत्येक लॉगर रूट लॉगर से कॉन्फ़िगरेशन इनहेरिट करता है।

— इलायस स्ट्रील

@ मायकेविलियम्सन getLoggerहमेशा वैकल्पिक है। logging.info()विधि का उपयोग करते समय सीधे रूट लकड़हारे का उपयोग किया जाता है, जबकि getLogger()आपके पास अलग-अलग लकड़हारा हो सकता है, जिसमें भिन्न नाम और स्तर हो सकते हैं।

— मोनिका

Answer 3

स्ट्रीम हैंडलर, फाइल हैंडलर, रोटेटिंग फाइल हैंडलर और एसएमटीपी हैंडलर के साथ उदाहरण

from logging.config import dictConfig

LOGGING_CONFIG = {
    'version': 1,
    'loggers': {
        '': {  # root logger
            'level': 'NOTSET',
            'handlers': ['debug_console_handler', 'info_rotating_file_handler', 'error_file_handler', 'critical_mail_handler'],
        },
        'my.package': { 
            'level': 'WARNING',
            'propagate': False,
            'handlers': ['info_rotating_file_handler', 'error_file_handler' ],
        },
    },
    'handlers': {
        'debug_console_handler': {
            'level': 'DEBUG',
            'formatter': 'info',
            'class': 'logging.StreamHandler',
            'stream': 'ext://sys.stdout',
        },
        'info_rotating_file_handler': {
            'level': 'INFO',
            'formatter': 'info',
            'class': 'logging.handlers.RotatingFileHandler',
            'filename': 'info.log',
            'mode': 'a',
            'maxBytes': 1048576,
            'backupCount': 10
        },
        'error_file_handler': {
            'level': 'WARNING',
            'formatter': 'error',
            'class': 'logging.FileHandler',
            'filename': 'error.log',
            'mode': 'a',
        },
        'critical_mail_handler': {
            'level': 'CRITICAL',
            'formatter': 'error',
            'class': 'logging.handlers.SMTPHandler',
            'mailhost' : 'localhost',
            'fromaddr': '[e-mail]',
            'toaddrs': ['[e-mail]', '[e-mail]'],
            'subject': 'Critical error with application name'
        }
    },
    'formatters': {
        'info': {
            'format': '%(asctime)s-%(levelname)s-%(name)s::%(module)s|%(lineno)s:: %(message)s'
        },
        'error': {
            'format': '%(asctime)s-%(levelname)s-%(name)s-%(process)d::%(module)s|%(lineno)s:: %(message)s'
        },
    },

}

dictConfig(LOGGING_CONFIG)

Answer 4

मुझे नीचे Django v1.11.15 डिफ़ॉल्ट विन्यास मिला , आशा है कि यह मदद करता है

DEFAULT_LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'filters': {
        'require_debug_false': {
            '()': 'django.utils.log.RequireDebugFalse',
        },
        'require_debug_true': {
            '()': 'django.utils.log.RequireDebugTrue',
        },
    },
    'formatters': {
        'django.server': {
            '()': 'django.utils.log.ServerFormatter',
            'format': '[%(server_time)s] %(message)s',
        }
    },
    'handlers': {
        'console': {
            'level': 'INFO',
            'filters': ['require_debug_true'],
            'class': 'logging.StreamHandler',
        },
        'django.server': {
            'level': 'INFO',
            'class': 'logging.StreamHandler',
            'formatter': 'django.server',
        },
        'mail_admins': {
            'level': 'ERROR',
            'filters': ['require_debug_false'],
            'class': 'django.utils.log.AdminEmailHandler'
        }
    },
    'loggers': {
        'django': {
            'handlers': ['console', 'mail_admins'],
            'level': 'INFO',
        },
        'django.server': {
            'handlers': ['django.server'],
            'level': 'INFO',
            'propagate': False,
        },
    }
}

Comments

यह उदाहरण ठीक है, लेकिन मुझे लगता है कि स्वीकृत उत्तर से परे खड़े होना चाहिए, कुछ स्पष्टीकरण से मदद मिलेगी।

— माइक विलियमसन

Answer 5

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import logging
import logging.handlers
from logging.config import dictConfig

logger = logging.getLogger(__name__)

DEFAULT_LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
}
def configure_logging(logfile_path):
    """
    Initialize logging defaults for Project.

    :param logfile_path: logfile used to the logfile
    :type logfile_path: string

    This function does:

    - Assign INFO and DEBUG level to logger file handler and console handler

    """
    dictConfig(DEFAULT_LOGGING)

    default_formatter = logging.Formatter(
        "[%(asctime)s] [%(levelname)s] [%(name)s] [%(funcName)s():%(lineno)s] [PID:%(process)d TID:%(thread)d] %(message)s",
        "%d/%m/%Y %H:%M:%S")

    file_handler = logging.handlers.RotatingFileHandler(logfile_path, maxBytes=10485760,backupCount=300, encoding='utf-8')
    file_handler.setLevel(logging.INFO)

    console_handler = logging.StreamHandler()
    console_handler.setLevel(logging.DEBUG)

    file_handler.setFormatter(default_formatter)
    console_handler.setFormatter(default_formatter)

    logging.root.setLevel(logging.DEBUG)
    logging.root.addHandler(file_handler)
    logging.root.addHandler(console_handler)



[31/10/2015 22:00:33] [DEBUG] [yourmodulename] [yourfunction_name():9] [PID:61314 TID:140735248744448] this is logger infomation from hello module