मैं कस्टम फ़ील्ड को Python लॉग फॉर्मेट स्ट्रिंग में कैसे जोड़ूँ?

Question 1

मेरा वर्तमान प्रारूप स्ट्रिंग है:

formatter = logging.Formatter('%(asctime)s : %(message)s')

और मैं एक नया फ़ील्ड जोड़ना चाहता हूं, app_nameजिसका प्रत्येक स्क्रिप्ट में एक अलग मान होगा जिसमें यह फ़ॉर्मेटर होता है।

import logging
formatter = logging.Formatter('%(asctime)s %(app_name)s : %(message)s')
syslog.setFormatter(formatter)
logger.addHandler(syslog)

लेकिन मुझे यकीन नहीं है कि app_nameप्रारूप स्ट्रिंग में प्रक्षेप करने के लिए लॉगर के लिए उस मान को कैसे पारित किया जाए । मैं स्पष्ट रूप से इसे हर बार पास करके लॉग संदेश में प्रदर्शित होने के लिए प्राप्त कर सकता हूं लेकिन यह गड़बड़ है।

मैंने कोशिश की:

logging.info('Log message', app_name='myapp')
logging.info('Log message', {'app_name', 'myapp'})
logging.info('Log message', 'myapp')

लेकिन कोई काम नहीं।

Question 2

आप एक लॉगऑगर एडेप्टर का उपयोग कर सकते हैं ताकि आपको हर लॉगिंग कॉल के साथ अतिरिक्त जानकारी न देनी पड़े:

import logging
extra = {'app_name':'Super App'}

logger = logging.getLogger(__name__)
syslog = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s %(app_name)s : %(message)s')
syslog.setFormatter(formatter)
logger.setLevel(logging.INFO)
logger.addHandler(syslog)

logger = logging.LoggerAdapter(logger, extra)
logger.info('The sky is so blue')

लॉग (कुछ इस तरह)

2013-07-09 17:39:33,596 Super App : The sky is so blue

फिल्टर का उपयोग प्रासंगिक जानकारी जोड़ने के लिए भी किया जा सकता है।

import logging

class AppFilter(logging.Filter):
    def filter(self, record):
        record.app_name = 'Super App'
        return True

logger = logging.getLogger(__name__)
logger.addFilter(AppFilter())
syslog = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s %(app_name)s : %(message)s')
syslog.setFormatter(formatter)
logger.setLevel(logging.INFO)
logger.addHandler(syslog)

logger.info('The sky is so blue')

एक समान लॉग रिकॉर्ड बनाता है।

Question 3

आपको अतिरिक्त को एक पैरामीटर के रूप में पारित करने की आवश्यकता है ताकि इसे इस तरह से किया जा सके।

logging.info('Log message', extra={'app_name': 'myapp'})

प्रमाण:

>>> import logging
>>> logging.basicConfig(format="%(foo)s - %(message)s")
>>> logging.warning('test', extra={'foo': 'bar'})
bar - test

इसके अलावा, एक नोट के रूप में, यदि आप किसी संदेश को बिना पास किए पास करने की कोशिश करते हैं, तो यह विफल हो जाएगा।

>>> logging.warning('test')
Traceback (most recent call last):
  File "/usr/lib/python2.7/logging/__init__.py", line 846, in emit
    msg = self.format(record)
  File "/usr/lib/python2.7/logging/__init__.py", line 723, in format
    return fmt.format(record)
  File "/usr/lib/python2.7/logging/__init__.py", line 467, in format
    s = self._fmt % record.__dict__
KeyError: 'foo'
Logged from file <stdin>, line 1

Question 4

python3

Python3.2 के रूप में आप अब LogRecordFactory का उपयोग कर सकते हैं

>>> import logging
>>> logging.basicConfig(format="%(custom_attribute)s - %(message)s")
>>> old_factory = logging.getLogRecordFactory()
>>> def record_factory(*args, **kwargs):
        record = old_factory(*args, **kwargs)
        record.custom_attribute = "my-attr"
        return record

>>> logging.setLogRecordFactory(record_factory)
>>> logging.info("hello")
my-attr - hello

निश्चित रूप record_factoryसे किसी भी कॉल करने योग्य होने के लिए अनुकूलित किया जा सकता है और custom_attributeयदि आप फ़ैक्टरी कॉल करने योग्य का संदर्भ रखते हैं तो मूल्य को अपडेट किया जा सकता है।

एडेप्टर / फिल्टर का उपयोग करने से बेहतर क्यों है?

आपको एप्लिकेशन के आसपास अपना लकड़हारा पास करने की आवश्यकता नहीं है
यह वास्तव में तीसरे पक्ष के पुस्तकालयों के साथ काम करता है जो अपने स्वयं के लकड़हारे (केवल कॉल करके logger = logging.getLogger(..)) का उपयोग करता है अब एक ही लॉग प्रारूप होगा। (यह फ़िल्टर्स / एडेप्टर के मामले में नहीं है जहाँ आपको एक ही लकड़हारे ऑब्जेक्ट का उपयोग करने की आवश्यकता है)
आप कई कारखानों को स्टैक / चेन कर सकते हैं

Question 5

एक अन्य तरीका एक कस्टम लॉगर एडेप्टर बनाना है। यह विशेष रूप से तब उपयोगी है जब आप प्रारूप को बदल नहीं सकते हैं या यदि आपका प्रारूप उस कोड के साथ साझा किया गया है जो अद्वितीय कुंजी (आपके मामले में app.name ) को नहीं भेजता है :

class LoggerAdapter(logging.LoggerAdapter):
    def __init__(self, logger, prefix):
        super(LoggerAdapter, self).__init__(logger, {})
        self.prefix = prefix

    def process(self, msg, kwargs):
        return '[%s] %s' % (self.prefix, msg), kwargs

और आपके कोड में, आप हमेशा की तरह अपने लकड़हारे को पैदा और शुरू करेंगे:

    logger = logging.getLogger(__name__)
    # Add any custom handlers, formatters for this logger
    myHandler = logging.StreamHandler()
    myFormatter = logging.Formatter('%(asctime)s %(message)s')
    myHandler.setFormatter(myFormatter)
    logger.addHandler(myHandler)
    logger.setLevel(logging.INFO)

अंत में, आप आवश्यकतानुसार एक उपसर्ग जोड़ने के लिए रैपर एडेप्टर बनाएंगे:

    logger = LoggerAdapter(logger, 'myapp')
    logger.info('The world bores you when you are cool.')

आउटपुट कुछ इस तरह दिखाई देगा:

2013-07-09 17:39:33,596 [myapp] The world bores you when you are cool.

Question 6

मुझे इसे लागू करने के बाद यह SO प्रश्न मिला। आशा है कि यह किसी की मदद करता है। नीचे दिए गए कोड में, मैं claim_idलकड़हारा प्रारूप में एक अतिरिक्त कुंजी प्रेरित कर रहा हूं । जब भी claim_idवातावरण में कोई कुंजी मौजूद होगी, वह दावा_ लॉग करेगा । मेरे उपयोग के मामले में, मुझे AWS लैम्ब्डा फ़ंक्शन के लिए इस जानकारी को लॉग करने की आवश्यकता थी।

import logging
import os

LOG_FORMAT = '%(asctime)s %(name)s %(levelname)s %(funcName)s %(lineno)s ClaimID: %(claim_id)s: %(message)s'


class AppLogger(logging.Logger):

    # Override all levels similarly - only info overriden here

    def info(self, msg, *args, **kwargs):
        return super(AppLogger, self).info(msg, extra={"claim_id": os.getenv("claim_id", "")})


def get_logger(name):
    """ This function sets log level and log format and then returns the instance of logger"""
    logging.setLoggerClass(AppLogger)
    logging.basicConfig(level=logging.INFO, format=LOG_FORMAT)
    logger = logging.getLogger(name)
    logger.setLevel(logging.INFO)
    return logger


LOGGER = get_logger(__name__)

LOGGER.info("Hey")
os.environ["claim_id"] = "12334"
LOGGER.info("Hey")

Gist: https://gist.github.com/ramanujam/306f2e4e1506f302504fb67abef50652

Question 7

स्वीकृत उत्तर लॉगफ़ाइल में प्रारूप को लॉग नहीं करता था, जबकि प्रारूप sys आउटपुट में परिलक्षित होता था। वैकल्पिक रूप से मैंने एक सरल दृष्टिकोण का इस्तेमाल किया और इस तरह काम किया;

logging.basicConfig(filename="mylogfile.test",
                    filemode="w+",
                    format='%(asctime)s: ' +app_name+': %(message)s ',
                    level=logging.DEBUG)

स्निपेट का विस्तार करें

Question 8

Mr2ert के उत्तर का उपयोग करते हुए, मैं इस आरामदायक समाधान के साथ आया (हालांकि मुझे लगता है कि यह अनुशंसित नहीं है) - कस्टम तर्क को स्वीकार करने और extraविधियों के अंदर शब्दकोश बनाने के लिए अंतर्निहित लॉगिंग विधियों को ओवरराइड करें :

import logging

class CustomLogger(logging.Logger):

   def debug(self, msg, foo, *args, **kwargs):
       extra = {'foo': foo}

       if self.isEnabledFor(logging.DEBUG):
            self._log(logging.DEBUG, msg, args, extra=extra, **kwargs)

   *repeat for info, warning, etc*

logger = CustomLogger('CustomLogger', logging.DEBUG)
formatter = logging.Formatter('%(asctime)s [%(foo)s] %(message)s') 
handler = logging.StreamHandler()
handler.setFormatter(formatter) 
logger.addHandler(handler)

logger.debug('test', 'bar')

आउटपुट:

2019-03-02 20:06:51,998 [bar] test

यह संदर्भ के लिए फ़ंक्शन में बनाया गया है:

def debug(self, msg, *args, **kwargs):
    """
    Log 'msg % args' with severity 'DEBUG'.

    To pass exception information, use the keyword argument exc_info with
    a true value, e.g.

    logger.debug("Houston, we have a %s", "thorny problem", exc_info=1)
    """
    if self.isEnabledFor(DEBUG):
        self._log(DEBUG, msg, args, **kwargs)

Question 9

आयात लॉगिंग;

वर्ग लॉगफ़िल्टर (लॉगिंग। फ़िल्टर):

def __init__(self, code):
    self.code = code

def filter(self, record):
    record.app_code = self.code
    return True

logging.basicConfig (प्रारूप = '[% (asctime) s:% (स्तरनाम) s] :: [% (मॉड्यूल) s ->% (नाम) s] - APP_CODE:% (appcode कोड) - MSG:% (संदेश) ) एस ');

कक्षा लकड़हारा:

def __init__(self, className):
    self.logger = logging.getLogger(className)
    self.logger.setLevel(logging.ERROR)

@staticmethod
def getLogger(className):
    return Logger(className)

def logMessage(self, level, code, msg):
    self.logger.addFilter(LogFilter(code))

    if level == 'WARN':        
        self.logger.warning(msg)
    elif level == 'ERROR':
        self.logger.error(msg)
    else:
        self.logger.info(msg)

वर्ग परीक्षण: लकड़हारा = लकड़हारा।लोगर ('टेस्ट')

if __name__=='__main__':
    logger.logMessage('ERROR','123','This is an error')