Використання журналу в декількох модулях

У мене є невеликий проект python, який має таку структуру -

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), тому все, що вам потрібно зробити, це просто налаштувати кореневий реєстратор. Цього можна досягти за допомогою logging.config.fileConfig(власного конфігурації для реєстраторів) або logging.basicConfig(встановлює кореневий реєстратор) Налаштування входу в модуль входу ( __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!")

Для отримання додаткової інформації див Посібник з розширеного ведення журналу .

Я завжди роблю це як нижче.

Використовуйте один файл python, щоб налаштувати мій журнал як шаблон однотонної форми, який назвав ' 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.

Хоча це, безумовно, можливо обійти (ones_existing_Loggers = Неправдиво), реально багато клієнтів вашої бібліотеки не знають про цю поведінку і не отримуватимуть ваші журнали. Полегшіть своїм клієнтам, завжди телефонуючи 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 в основному, встановіть invalid_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 .py у мене є щось на кшталт:

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

@ Рішення Яркі здавалося кращим. Я хотів би додати дещо більше до нього -

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)

створив приємний файл утиліти з іменем 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')

Новачок у python, тому я не знаю, чи доцільно це, але він чудово підходить для того, щоб не писати котлован.

Ваш проект повинен мати 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__, матиме цю проблему.