Регистратор файлов / модулей в Python

Если вы хотите, чтобы имя регистратора указывало на модуль, в котором он использовался, вы можете использовать _ 1_ и передайте __name__ в качестве (необязательного) аргумента, как описано в здесь.

Если вы хотите использовать имена вроде DEBUG(), сделайте что-нибудь подобное в каждом своих файлах ...

LOG_MODULE_NAME = logging.getLogger(__name__)

def DEBUG(msg):
    global LOG_MODULE_NAME
    LOG_MODULE_NAME.debug(msg)

Я не понимаю, как глобальные пространства имен на самом деле работают в Python ... в этом ответе говорится

у каждого модуля есть свое собственное «глобальное» пространство имен.

Так что я думаю, у вас все будет хорошо, потому что LOG_MODULE_NAME не будет конфликтовать между модулями.

Я считаю, что этот подход даст вам один файл журнала, в котором строки будут выглядеть следующим образом:

DEBUG:my_module:Entering function
WARN:my_module:I thought it would be 1
DEBUG:my_module:Exiting function
DEBUG:root:Exiting main.py

Недостаточно интуитивно? Вам нужен модуль inpsect, который даст вам много информации о программе во время ее работы. Это, например, даст вам текущий номер строки.

Ваше замечание о «настройке уровней журнала на уровне модуля» заставляет меня думать, что вам нужно что-то вроде _ 8_. Вы можете попытаться раздавить это вот так:

LOG_MODULE_NAME = logging.getLogger(__name__)
MODULE_LOG_LEVEL = log.LVL_WARN

def DEBUG(msg):
    if MODULE_LOG_LEVEL = log.LVL_DEBUG:
        global LOG_MODULE_NAME
        LOG_MODULE_NAME.debug(msg)

Однако у меня недостаточно опыта работы с модулем logging, чтобы рассказать вам, как можно динамически изменять уровни журналов каждого модуля.

Эти ответы, похоже, пропускают очень простую идею о том, что функции являются первоклассными объектами, которые позволяют:

def a_function(n):
    pass

MY_HAPPY_NAME = a_function
MY_HAPPY_NAME(15) # which is equivalent to a_function(15)

Кроме, я рекомендую вам не делать этого. соглашения о кодировании PEP8 широко используются, потому что жизнь слишком коротка, чтобы заставить меня читать идентификаторы в COBOLy так, как вам нравится их писать.

В некоторых других ответах также используется оператор global, который почти всегда не нужен в Python. Если вы создаете экземпляры регистратора на уровне модуля, тогда

import logging

log = logging.getLogger(__name__)

def some_method():
    ...
    log.debug(...)

- это вполне работоспособный и лаконичный способ использования переменной log на уровне модуля. Вы даже могли бы сделать

log = logging.getLogger(__name__)
DEBUG = log.debug

def some_method():
    ...
    DEBUG(...)

но я оставляю за собой право называть это уродливым.

Чтобы расширить понятие @ 2rs2ts, вы можете просто регистрироваться по модулям, как показано в Python регистрация HOWTO.

Хорошее соглашение, которое следует использовать при именовании средств ведения журнала, - использовать средство ведения журнала на уровне модуля в каждом модуле, который использует ведение журнала, с следующим названием:

logger = logging.getLogger(__name__) 

Это означает, что имена регистраторов отслеживают иерархию пакетов / модулей, и интуитивно очевидно, где события регистрируются только по имени регистратора.

Сделайте первые 2 строки всех ваших файлов так:

import logging
logger = logging.getLogger(__name__) 

Тогда у вас есть ведение журнала для каждого модуля, которое легко настраивается.

Вы можете войти на разные уровни через:

logger.debug("I just saw this %s" , var )
logger.info("I just saw this %s" , var )
logger.warn("I just saw this %s" , var )

Обратите внимание, что я передал переменную шаблона строки как *arg, а не %, чтобы немедленно создать шаблон строки. Если ваш регистратор настроен на более высокий уровень, чем уровень, на котором вы входите, вы экономите циклы ЦП. В logging документации есть несколько подобных приемов.

Вы можете установить уровень ведения журнала и место входа в любое приложение / сценарий, который вы запускаете; модуль регистрации сделает все остальное.

Более чистое решение можно найти по этому другому вопросу. Более чистый способ настроить ведение журнала для библиотеки - использовать эти несколько строк в каждом вашем модуле.

import logging
logging.getLogger(__name__).addHandler(logging.NullHandler())

Ваш основной скрипт (например, мой script.py) отвечает за:

• выполнение конфигурации ведения журнала, например с помощью logging.basicConfig() или _ 4_
• выбор Formatter для использования в событиях журнала.
• выбор logging.handlers для отправки события в нужное место (например, удаленное ведение журнала, консоль, файл ...)

Возьмем ваш пример:

def myFunc(x):
    DEBUG("Entering function")
    if x != 1:
         WARN("I thought it would be 1")
    DEBUG("Exiting function")
    return x+1

и ваш ожидаемый результат:

[WARN:my_module - my_module.py:9] I thought it would be 1
[DEBUG:main - main.py:11] Exiting main.py

Как мы выясним, что DEBUG("Existing main.py") произошло main.py:11? Очевидный ответ: вы не можете, если вы не проверите фрейм и не выясните, кто звонит. Если вы хотите определить функцию DEBUG() в модуле log.py, вы не получите правильных записей. Функции очень отличаются от макросов, вам нужно определить функцию, и нет встроенной замены, поэтому вы больше не находитесь в одном кадре.

Просто для удовольствия я написал решение, используя Самоанализ с inspect модулем (примечание: не запускайте это как производственный код), но на самом деле, чтобы ответить на вопросы, «где была вызвана эта функция и в какой строке?» нужно проделать некоторую работу.

• bar.py

  # file: bar.py
  # this is just a module to show DEBUG works when used in a different module
  from log import DEBUG
  
  def baz():
      DEBUG('oh hai from baz')
  

• log.py

  # file: log.py
  import inspect
  import logging
  
  def DEBUG(msg, *args):
      curframe = inspect.currentframe()
      try:
          # http://docs.python.org/2/library/inspect.html#inspect.getouterframes
          _, filename, _, code, _, _ = inspect.getouterframes(curframe, 2)[1]
          logging.debug('[%s:%s] '+msg, filename, code, *args)
      finally:
          del curframe
  

• основной скрипт script.py

  # file: script.py
  # responsible for the logging setup.
  import logging
  from log import DEBUG
  from bar import baz
  
  def foo():
      DEBUG('oh hai')
  
  if __name__ == '__main__':
      logging.basicConfig()
      logging.root.setLevel(logging.DEBUG)
      foo()
      baz()
  

Очевидная проблема с моим решением заключается в том, что мы используем только регистратор root:

$ python script.py 
DEBUG:root:[script.py:foo] oh hai
DEBUG:root:[/Users/dnozay/Desktop/bar.py:baz] oh hai from baz

Учитывая все эти элементы, я бы не одобрил повторную реализацию функциональности, уже доступной в logging.