Sử dụng đăng nhập trong nhiều mô-đun

Tôi có một dự án python nhỏ có cấu trúc như sau -

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

Tôi dự định sử dụng mô-đun ghi nhật ký mặc định để in thông báo ra thiết bị xuất chuẩn và tệp nhật ký. Để sử dụng mô-đun đăng nhập, một số khởi tạo được yêu cầu -

import logging.config

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

logger.info('testing')

Hiện tại, tôi thực hiện việc khởi tạo này trong mọi mô-đun trước khi tôi bắt đầu đăng nhập thông điệp. Có thể thực hiện việc khởi tạo này chỉ một lần ở một nơi để các cài đặt tương tự được sử dụng lại bằng cách đăng nhập toàn bộ dự án không?

Thực hành tốt nhất là, trong mỗi mô-đun, để có một bộ ghi chép được định nghĩa như thế này:

import logging
logger = logging.getLogger(__name__)

gần đỉnh của mô-đun, và sau đó trong mã khác trong mô-đun làm ví dụ

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

Nếu bạn cần chia nhỏ hoạt động ghi nhật ký trong một mô-đun, hãy sử dụng, vd

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

và đăng nhập loggerAvà loggerBkhi thích hợp.

Trong chương trình hoặc chương trình chính của bạn, hãy làm, ví dụ:

def main():
    "your program code"

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

hoặc là

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

if __name__ == '__main__':
    main()

Xem ở đây để đăng nhập từ nhiều mô-đun và ở đây để ghi nhật ký cấu hình cho mã sẽ được sử dụng làm mô-đun thư viện bởi mã khác.

Cập nhật: Khi gọi fileConfig(), bạn có thể muốn chỉ địnhdisable_existing_loggers=False nếu bạn đang sử dụng Python 2.6 trở lên (xem tài liệu để biết thêm thông tin). Giá trị mặc định là Trueđể tương thích ngược, điều này làm cho tất cả các logger hiện tại bị vô hiệu hóa fileConfig()trừ khi chúng hoặc tổ tiên của chúng được đặt tên rõ ràng trong cấu hình. Với giá trị được đặt thành False, các logger hiện có được để lại một mình. Nếu sử dụng Python 2.7 / Python 3.2 trở lên, bạn có thể muốn xem xét dictConfig()API tốt hơn fileConfig()vì nó mang lại nhiều quyền kiểm soát hơn cho cấu hình.

Trên thực tế mỗi logger là con của logger gói của cha mẹ (tức là package.subpackage.modulecấu hình thừa hưởng từ package.subpackage), vì vậy tất cả bạn cần làm chỉ là cấu hình các logger gốc. Điều này có thể đạt được bằng cách logging.config.fileConfig(config của riêng bạn cho logger) hoặc logging.basicConfig(bộ các logger root) Cài đặt đăng nhập trong mô-đun nhập của bạn ( __main__.pyhoặc bất cứ điều gì bạn muốn chạy, chẳng hạn main_script.py. __init__.pyHoạt động tốt)

sử dụng basicConfig:

# package/__main__.py
import logging
import sys

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

sử dụng fileConfig:

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

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

và sau đó tạo mọi logger bằng cách sử dụng:

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

log.info("Hello logging!")

Để biết thêm thông tin, xem Hướng dẫn đăng nhập nâng cao .

Tôi luôn luôn làm như dưới đây.

Sử dụng một tệp python duy nhất để định cấu hình nhật ký của tôi dưới dạng mẫu đơn có tên ' 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')

Trong một mô-đun khác, chỉ cần nhập cấu hình.

from log_conf import Logger

Logger.logr.info("Hello World")

Đây là một mẫu singleton để đăng nhập, đơn giản và hiệu quả.

Một vài trong số những câu trả lời này gợi ý rằng ở đầu mô-đun bạn làm

import logging
logger = logging.getLogger(__name__)

Theo hiểu biết của tôi rằng đây được coi là thực hành rất xấu . Lý do là cấu hình tập tin sẽ vô hiệu hóa tất cả các logger hiện có theo mặc định. Ví dụ

#my_module
import logging

logger = logging.getLogger(__name__)

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

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

Và trong mô-đun chính của bạn:

#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()

Bây giờ nhật ký được chỉ định trong log.ini sẽ trống, vì trình ghi nhật ký hiện tại đã bị vô hiệu hóa bởi lệnh gọi fileconfig.

Mặc dù chắc chắn có thể khắc phục điều này (vô hiệu hóa_ex hiện_Loggers = Sai), nhưng thực tế nhiều khách hàng của thư viện của bạn sẽ không biết về hành vi này và sẽ không nhận được nhật ký của bạn. Làm cho nó dễ dàng cho khách hàng của bạn bằng cách luôn gọi log.getLogger cục bộ. Hat Tip: Tôi đã tìm hiểu về hành vi này từ Trang web của Victor Lin .

Vì vậy, thực hành tốt là thay vì luôn gọi log.getLogger cục bộ. Ví dụ

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

Ngoài ra, nếu bạn sử dụng fileconfig trong chính của mình, hãy đặt vô hiệu hóa_ex hiện_loggers = Sai, chỉ trong trường hợp các nhà thiết kế thư viện của bạn sử dụng các phiên bản logger cấp mô-đun.

Một cách đơn giản để sử dụng một thể hiện của thư viện ghi nhật ký trong nhiều mô-đun đối với tôi là giải pháp sau:

cơ sở_logger

import logging

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

Những tập tin khác

from base_logger import logger

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

Ném vào một giải pháp khác.

Trong init .py của mô-đun của tôi, tôi có một cái gì đó như:

# 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

Sau đó, trong mỗi mô-đun tôi cần một logger, tôi làm:

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

Khi các bản ghi bị bỏ lỡ, bạn có thể phân biệt nguồn của chúng theo mô-đun chúng đến từ.

Bạn cũng có thể nghĩ ra thứ gì đó như thế này!

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

Bây giờ bạn có thể sử dụng nhiều logger trong cùng một mô-đun và trên toàn bộ dự án nếu phần trên được xác định trong một mô-đun riêng biệt và được nhập trong các mô-đun khác là ghi nhật ký là bắt buộc.

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

@ Giải pháp của Yarkee có vẻ tốt hơn. Tôi muốn thêm một chút vào nó -

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)

Vì vậy, LoggerManager có thể là một bản cắm cho toàn bộ ứng dụng. Hy vọng nó có ý nghĩa và giá trị.

Có một vài câu trả lời. tôi đã kết thúc với một giải pháp tương tự nhưng khác biệt có ý nghĩa với tôi, có lẽ nó cũng có ý nghĩa với bạn. Mục tiêu chính của tôi là có thể chuyển nhật ký cho người xử lý theo cấp độ của họ (nhật ký mức gỡ lỗi cho bảng điều khiển, cảnh báo và ở trên cho tệp):

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)

đã tạo một tập tin tiện ích có tên logger.py:

import logging

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

the jar.app là một giá trị mã hóa cứng trong bình. bộ ghi ứng dụng luôn bắt đầu với jar.app là tên của mô-đun.

Bây giờ, trong mỗi mô-đun, tôi có thể sử dụng nó trong chế độ sau:

from logger import get_logger
logger = get_logger(__name__)

logger.info("new log")

Điều này sẽ tạo ra một nhật ký mới cho "app.flask.MODULE_NAME" với nỗ lực tối thiểu.

Cách thực hành tốt nhất là tạo một mô-đun riêng biệt chỉ có một phương thức mà chúng ta có nhiệm vụ là cung cấp một trình xử lý logger cho phương thức gọi. Lưu tệp này dưới dạng 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

Bây giờ hãy gọi phương thức getlogger () bất cứ khi nào cần trình xử lý logger.

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

Mới sử dụng python nên tôi không biết điều này có nên không, nhưng nó hoạt động rất tốt vì không viết lại bản tóm tắt.

Dự án của bạn phải có init .py để có thể tải nó dưới dạng mô-đun

# 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) đề nghị đến từ đây

Sau đó, để sử dụng logger của bạn trong bất kỳ tập tin khác:

from [your module name here] import logger

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

Hãy cẩn thận:

1. Bạn phải chạy các tệp của mình dưới dạng các mô-đun, nếu không import [your module]sẽ không hoạt động:
   • python -m [your module name].[your filename without .py]
2. Tên của logger cho điểm vào của chương trình của bạn sẽ là __main__, nhưng bất kỳ giải pháp nào sử dụng __name__sẽ có vấn đề đó.