สตริงรูปแบบปัจจุบันของฉันคือ:

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')

แต่ไม่มีงานทำ

คุณสามารถใช้LoggerAdapterเพื่อที่คุณจะได้ไม่ต้องส่งข้อมูลเพิ่มเติมในทุกครั้งที่โทรบันทึก:

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')

สร้างบันทึกบันทึกที่คล้ายกัน

คุณต้องส่งคำสั่งเป็นพารามิเตอร์ไปยังส่วนเสริมเพื่อทำเช่นนั้น

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

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สามารถอัปเดตมูลค่าได้หากคุณยังคงอ้างอิงถึงโรงงานที่เรียกได้

เหตุใดจึงดีกว่าการใช้ Adapters / Filters

• คุณไม่จำเป็นต้องส่งคนตัดไม้ของคุณไปรอบ ๆ แอปพลิเคชัน
• ใช้งานได้จริงกับไลบรารีของบุคคลที่สามที่ใช้คนตัดไม้ของตัวเอง (โดยการโทรlogger = logging.getLogger(..)) ตอนนี้จะมีรูปแบบบันทึกเหมือนกัน (นี่ไม่ใช่กรณีของฟิลเตอร์ / อะแดปเตอร์ที่คุณต้องใช้อ็อบเจ็กต์คนตัดไม้เดียวกัน)
• คุณสามารถวางซ้อน / เชื่อมโรงงานได้หลายแห่ง

อีกวิธีหนึ่งคือการสร้าง LoggerAdapter แบบกำหนดเอง สิ่งนี้มีประโยชน์อย่างยิ่งเมื่อคุณไม่สามารถเปลี่ยนรูปแบบหรือหากรูปแบบของคุณแชร์กับโค้ดที่ไม่ส่งคีย์เฉพาะ (ในกรณีของคุณ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)

สุดท้ายคุณจะสร้างอะแดปเตอร์ Wrapper เพื่อเพิ่มคำนำหน้าตามต้องการ:

    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.

ฉันพบคำถาม SO นี้หลังจากดำเนินการด้วยตัวเอง หวังว่ามันจะช่วยใครบางคน ในโค้ดด้านล่างนี้ฉันกำลังสร้างคีย์พิเศษที่เรียกว่าclaim_idในรูปแบบคนตัดไม้ มันจะเข้าสู่ระบบ Claim_id เมื่อใดก็ตามที่มีclaim_idคีย์อยู่ในสภาพแวดล้อม ในกรณีการใช้งานของฉันฉันจำเป็นต้องบันทึกข้อมูลนี้สำหรับฟังก์ชัน AWS Lambda

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

คำตอบที่ยอมรับไม่ได้บันทึกรูปแบบในไฟล์บันทึกในขณะที่รูปแบบจะแสดงในเอาต์พุต sys อีกทางเลือกหนึ่งที่ฉันใช้วิธีการที่ง่ายกว่าและทำงานเป็น;

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

ด้วยการใช้คำตอบของ 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)

นำเข้าบันทึก;

คลาส LogFilter (logging.Filter):

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

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

logging.basicConfig (format = '[% (asctime) s:% (levelname) s] :: [% (module) s ->% (name) s] - APP_CODE:% (app_code) s - MSG:% (ข้อความ ) s ');

คลาส Logger:

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)

การทดสอบคลาส: logger = Logger.getLogger ('Test')

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