การใช้การบันทึกในหลายโมดูล

ฉันมีโครงการงูหลามขนาดเล็กที่มีโครงสร้างดังต่อไปนี้ -

Project 
 -- pkg01
   -- test01.py
 -- pkg02
   -- test02.py
 -- logging.conf

ฉันวางแผนที่จะใช้โมดูลบันทึกเริ่มต้นเพื่อพิมพ์ข้อความไปยัง stdout และไฟล์บันทึก ในการใช้โมดูลการบันทึกจำเป็นต้องเริ่มต้นบางอย่าง -

import logging.config

logging.config.fileConfig('logging.conf')
logger = logging.getLogger('pyApp')

logger.info('testing')

ในปัจจุบันฉันทำการเริ่มต้นนี้ในทุกโมดูลก่อนที่ฉันจะเริ่มบันทึกข้อความ เป็นไปได้หรือไม่ที่จะทำการเริ่มต้นนี้เพียงครั้งเดียวในที่เดียวซึ่งการตั้งค่าเดียวกันนี้สามารถนำกลับมาใช้ใหม่ได้โดยการบันทึกทั่วทั้งโครงการ?

แนวทางปฏิบัติที่ดีที่สุดคือในแต่ละโมดูลจะมีตัวบันทึกไว้ดังนี้:

import logging
logger = logging.getLogger(__name__)

ใกล้กับส่วนบนของโมดูลและจากนั้นในรหัสอื่น ๆ ในโมดูลทำเช่น

logger.debug('My message with %s', 'variable data')

หากคุณต้องการแบ่งกิจกรรมการบันทึกภายในโมดูลให้ใช้เช่น

loggerA = logging.getLogger(__name__ + '.A')
loggerB = logging.getLogger(__name__ + '.B')

และเข้าสู่ระบบloggerAและloggerBตามความเหมาะสม

ในโปรแกรมหลักหรือโปรแกรมของคุณให้ทำเช่น:

def main():
    "your program code"

if __name__ == '__main__':
    import logging.config
    logging.config.fileConfig('/path/to/logging.conf')
    main()

หรือ

def main():
    import logging.config
    logging.config.fileConfig('/path/to/logging.conf')
    # your program code

if __name__ == '__main__':
    main()

ดูที่นี่สำหรับการบันทึกจากหลายโมดูลและที่นี่สำหรับการกำหนดค่าการบันทึกสำหรับรหัสซึ่งจะใช้เป็นโมดูลไลบรารีด้วยรหัสอื่น

อัปเดต:เมื่อโทรfileConfig()คุณอาจต้องการระบุdisable_existing_loggers=Falseว่าคุณใช้ Python 2.6 หรือใหม่กว่า (ดูเอกสารสำหรับข้อมูลเพิ่มเติม) ค่าเริ่มต้นTrueสำหรับการเข้ากันได้แบบย้อนกลับซึ่งทำให้ตัวบันทึกที่มีอยู่ทั้งหมดจะถูกปิดใช้งานโดยfileConfig()ถ้าพวกเขาหรือบรรพบุรุษของพวกเขามีการตั้งชื่ออย่างชัดเจนในการกำหนดค่า ด้วยการตั้งค่าเป็นตัวFalseบันทึกที่มีอยู่จะถูกทิ้งไว้ตามลำพัง หากใช้ Python 2.7 / Python 3.2 หรือใหม่กว่าคุณอาจต้องการพิจารณาdictConfig()API ที่ดีกว่าfileConfig()เนื่องจากให้การควบคุมมากกว่าการกำหนดค่า

จริงๆแล้วทุกคนตัดไม้เป็นลูกของแพคเกจบันทึกของผู้ปกครอง (เช่นpackage.subpackage.moduleสืบทอดการกำหนดค่าจากpackage.subpackage)ดังนั้นสิ่งที่คุณต้องทำคือเพียงแค่การกำหนดค่า root logger ซึ่งสามารถทำได้โดยlogging.config.fileConfig(config ของคุณเองสำหรับ loggers) หรือlogging.basicConfig(ตั้งค่า root logger) . การตั้งค่าการเข้าสู่ระบบในโมดูลรายการของคุณ ( __main__.pyหรือสิ่งที่คุณต้องการที่จะทำงานเช่นmain_script.py. __init__.pyทำงานได้เช่นกัน)

ใช้ basicConfig:

# package/__main__.py
import logging
import sys

logging.basicConfig(stream=sys.stdout, level=logging.INFO)

ใช้ fileConfig:

# package/__main__.py
import logging
import logging.config

logging.config.fileConfig('logging.conf')

จากนั้นสร้างตัวบันทึกทุกตัวโดยใช้:

# package/submodule.py
# or
# package/subpackage/submodule.py
import logging
log = logging.getLogger(__name__)

log.info("Hello logging!")

สำหรับข้อมูลเพิ่มเติมดูสินค้าทุกประเภทเข้าสู่ระบบการสอน

ฉันมักจะทำมันดังต่อไปนี้

ใช้ไฟล์หลามเดียวเพื่อกำหนดค่าบันทึกของฉันเป็นรูปแบบซิงเกิลที่มีชื่อว่า ' log_conf.py'

#-*-coding:utf-8-*-

import logging.config

def singleton(cls):
    instances = {}
    def get_instance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return get_instance()

@singleton
class Logger():
    def __init__(self):
        logging.config.fileConfig('logging.conf')
        self.logr = logging.getLogger('root')

ในโมดูลอื่นเพียงนำเข้าการกำหนดค่า

from log_conf import Logger

Logger.logr.info("Hello World")

นี่คือรูปแบบซิงเกิลเพื่อเข้าสู่ระบบได้อย่างง่ายดายและมีประสิทธิภาพ

คำตอบเหล่านี้หลายคำแนะนำว่าที่ด้านบนของโมดูลที่คุณทำ

import logging
logger = logging.getLogger(__name__)

มันเป็นความเข้าใจของฉันที่นี้ถือว่าการปฏิบัติที่เลวร้ายมาก เหตุผลคือการกำหนดค่าไฟล์จะปิดการใช้งานบันทึกที่มีอยู่ทั้งหมดโดยค่าเริ่มต้น เช่น

#my_module
import logging

logger = logging.getLogger(__name__)

def foo():
    logger.info('Hi, foo')

class Bar(object):
    def bar(self):
        logger.info('Hi, bar')

และในโมดูลหลักของคุณ:

#main
import logging

# load my module - this now configures the logger
import my_module

# This will now disable the logger in my module by default, [see the docs][1] 
logging.config.fileConfig('logging.ini')

my_module.foo()
bar = my_module.Bar()
bar.bar()

ตอนนี้บันทึกที่ระบุใน logging.ini จะว่างเปล่าเนื่องจากตัวบันทึกที่มีอยู่ถูกปิดใช้งานโดยการเรียกใช้ fileconfig

แม้ว่าจะเป็นไปได้ที่จะหลีกเลี่ยงปัญหานี้ (disable_existing_Loggers = False) ลูกค้าของห้องสมุดของคุณจำนวนมากจะไม่ทราบเกี่ยวกับพฤติกรรมนี้และจะไม่ได้รับบันทึกของคุณ ทำให้ลูกค้าของคุณเป็นเรื่องง่ายด้วยการเรียก logging.getLogger ในพื้นที่เสมอ หมวกเคล็ดลับ: ผมได้เรียนรู้เกี่ยวกับพฤติกรรมนี้จากเว็บไซต์วิคเตอร์ของหลิน

ดังนั้นวิธีปฏิบัติที่ดีคือแทนที่จะเรียกใช้ logging.getLogger แบบโลคัลเสมอ เช่น

#my_module
import logging

logger = logging.getLogger(__name__)

def foo():
    logging.getLogger(__name__).info('Hi, foo')

class Bar(object):
    def bar(self):
        logging.getLogger(__name__).info('Hi, bar')    

นอกจากนี้หากคุณใช้ fileconfig ใน main ให้ตั้งค่า disable_existing_loggers = False ในกรณีที่นักออกแบบไลบรารีของคุณใช้อินสแตนซ์โมดูลตัวบันทึกระดับโมดูล

วิธีง่ายๆในการใช้อินสแตนซ์หนึ่งของไลบรารีการบันทึกในหลายโมดูลสำหรับฉันคือการติดตามวิธีแก้ไข:

base_logger.py

import logging

logger = logging
logger.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO)

ไฟล์อื่น ๆ

from base_logger import logger

if __name__ == '__main__':
    logger.info("This is an info message")

การขว้างด้วยวิธีอื่น

ใน. โมดูลinitของฉันฉันมีสิ่งต่อไปนี้:

# mymodule/__init__.py
import logging

def get_module_logger(mod_name):
  logger = logging.getLogger(mod_name)
  handler = logging.StreamHandler()
  formatter = logging.Formatter(
        '%(asctime)s %(name)-12s %(levelname)-8s %(message)s')
  handler.setFormatter(formatter)
  logger.addHandler(handler)
  logger.setLevel(logging.DEBUG)
  return logger

จากนั้นในแต่ละโมดูลฉันต้องการคนตัดไม้ฉันทำ:

# mymodule/foo.py
from [modname] import get_module_logger
logger = get_module_logger(__name__)

เมื่อพลาดการบันทึกคุณสามารถแยกความแตกต่างของแหล่งที่มาโดยโมดูลที่มาจาก

คุณสามารถคิดอะไรทำนองนี้!

def get_logger(name=None):
    default = "__app__"
    formatter = logging.Formatter('%(levelname)s: %(asctime)s %(funcName)s(%(lineno)d) -- %(message)s',
                              datefmt='%Y-%m-%d %H:%M:%S')
    log_map = {"__app__": "app.log", "__basic_log__": "file1.log", "__advance_log__": "file2.log"}
    if name:
        logger = logging.getLogger(name)
    else:
        logger = logging.getLogger(default)
    fh = logging.FileHandler(log_map[name])
    fh.setFormatter(formatter)
    logger.addHandler(fh)
    logger.setLevel(logging.DEBUG)
    return logger

ตอนนี้คุณสามารถใช้ตัวบันทึกหลายตัวในโมดูลเดียวกันและทั่วทั้งโครงการหากกำหนดไว้ข้างต้นในโมดูลแยกต่างหากและนำเข้าในโมดูลอื่น ๆ จำเป็นต้องมีการบันทึก

a=get_logger("__app___")
b=get_logger("__basic_log__")
a.info("Starting logging!")
b.debug("Debug Mode")

@ วิธีแก้ปัญหาของ Yarkee ดูดีขึ้น ฉันต้องการเพิ่มอีกแล้ว -

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances.keys():
            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
        return cls._instances[cls]


class LoggerManager(object):
    __metaclass__ = Singleton

    _loggers = {}

    def __init__(self, *args, **kwargs):
        pass

    @staticmethod
    def getLogger(name=None):
        if not name:
            logging.basicConfig()
            return logging.getLogger()
        elif name not in LoggerManager._loggers.keys():
            logging.basicConfig()
            LoggerManager._loggers[name] = logging.getLogger(str(name))
        return LoggerManager._loggers[name]    


log=LoggerManager().getLogger("Hello")
log.setLevel(level=logging.DEBUG)

ดังนั้น LoggerManager สามารถเชื่อมต่อกับแอปพลิเคชันทั้งหมดได้ หวังว่ามันจะสมเหตุสมผลและคุ้มค่า

มีหลายคำตอบ ฉันลงเอยด้วยวิธีแก้ปัญหาที่คล้ายกัน แต่แตกต่างกันซึ่งทำให้ฉันรู้สึกว่าบางทีมันก็สมเหตุสมผลสำหรับคุณเช่นกัน วัตถุประสงค์หลักของฉันคือสามารถส่งบันทึกไปยังตัวจัดการตามระดับ (บันทึกระดับการดีบักไปยังคอนโซลคำเตือนและเหนือไปยังไฟล์):

from flask import Flask
import logging
from logging.handlers import RotatingFileHandler

app = Flask(__name__)

# make default logger output everything to the console
logging.basicConfig(level=logging.DEBUG)

rotating_file_handler = RotatingFileHandler(filename="logs.log")
rotating_file_handler.setLevel(logging.INFO)

app.logger.addHandler(rotating_file_handler)

สร้างไฟล์ util ที่ดีชื่อ logger.py:

import logging

def get_logger(name):
    return logging.getLogger("flask.app." + name)

flask.app เป็นค่าฮาร์ดโค้ดในขวด แอปพลิเคชันตัวบันทึกเริ่มต้นด้วย flask.app เป็นชื่อโมดูลเสมอ

ตอนนี้ในแต่ละโมดูลฉันสามารถใช้งานได้ในโหมดต่อไปนี้:

from logger import get_logger
logger = get_logger(__name__)

logger.info("new log")

สิ่งนี้จะสร้างบันทึกใหม่สำหรับ "app.flask.MODULE_NAME" ด้วยความพยายามขั้นต่ำ

แนวทางปฏิบัติที่ดีที่สุดคือการสร้างโมดูลแยกต่างหากซึ่งมีเพียงวิธีเดียวที่มีหน้าที่ที่เราจะต้องให้ตัวจัดการคนตัดไม้กับวิธีการโทร บันทึกไฟล์นี้เป็น m_logger.py

import logger, logging

def getlogger():
    # logger
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.DEBUG)
    # create console handler and set level to debug
    #ch = logging.StreamHandler()
    ch = logging.FileHandler(r'log.txt')
    ch.setLevel(logging.DEBUG)
    # create formatter
    formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    # add formatter to ch
    ch.setFormatter(formatter)
    # add ch to logger
    logger.addHandler(ch)
    return logger

ตอนนี้เรียกใช้เมธอด getlogger () เมื่อใดก็ตามที่ต้องการตัวจัดการตัวบันทึก

from m_logger import getlogger
logger = getlogger()
logger.info('My mssg')

ใหม่สำหรับงูใหญ่ดังนั้นฉันไม่ทราบว่าเป็นสิ่งที่แนะนำหรือไม่

โครงการของคุณต้องมีinit .py ดังนั้นจึงสามารถโหลดเป็นโมดูลได้

# Put this in your module's __init__.py
import logging.config
import sys

# I used this dictionary test, you would put:
# logging.config.fileConfig('logging.conf')
# The "" entry in loggers is the root logger, tutorials always 
# use "root" but I can't get that to work
logging.config.dictConfig({
    "version": 1,
    "formatters": {
        "default": {
            "format": "%(asctime)s %(levelname)s %(name)s %(message)s"
        },
    },
    "handlers": {
        "console": {
            "level": 'DEBUG',
            "class": "logging.StreamHandler",
            "stream": "ext://sys.stdout"
        }
    },
    "loggers": {
        "": {
            "level": "DEBUG",
            "handlers": ["console"]
        }
    }
})

def logger():
    # Get the name from the caller of this function
    return logging.getLogger(sys._getframe(1).f_globals['__name__'])

sys._getframe(1)คำแนะนำมาจากที่นี่

จากนั้นใช้ตัวบันทึกของคุณในไฟล์อื่น:

from [your module name here] import logger

logger().debug("FOOOOOOOOO!!!")

คำเตือน:

1. คุณต้องเรียกใช้ไฟล์ของคุณเป็นโมดูลมิฉะนั้นimport [your module]จะไม่ทำงาน:
   • python -m [your module name].[your filename without .py]
2. ชื่อของคนตัดไม้สำหรับจุดเริ่มต้นของโปรแกรมของคุณจะเป็น__main__แต่การแก้ปัญหาใด ๆ ที่ใช้__name__จะมีปัญหานั้น