Python логирование всех ошибок

Сталкивались ли вы с трудностями при отладке Python-кода? Если это так — то изучение того, как наладить логирование (журналирование, logging) в Python, способно помочь вам упростить задачи, решаемые при отладке.

Вы, кроме того, узнаете о том, как Sentry Python SDK способен помочь вам в мониторинге приложений и в упрощении рабочих процессов, связанных с отладкой кода. Платформа Sentry обладает нативной интеграцией со встроенным Python-модулем logging, и, кроме того, предоставляет подробную информацию об ошибках приложения и о проблемах с производительностью, которые в нём возникают.

Начало работы с Python-модулем logging

В Python имеется встроенный модуль logging, применяемый для решения задач логирования. Им мы будем пользоваться в этом руководстве. Первый шаг к профессиональному логированию вы можете выполнить прямо сейчас, импортировав этот модуль в своё рабочее окружение.

import logging

Встроенный модуль логирования Python даёт нам простой в использовании функционал и предусматривает пять уровней логирования. Чем выше уровень — тем серьёзнее неприятность, о которой сообщает соответствующая запись. Самый низкий уровень логирования — это debug (10), а самый высокий — это critical (50).

Дадим краткие характеристики уровней логирования:

• Debug (10): самый низкий уровень логирования, предназначенный для отладочных сообщений, для вывода диагностической информации о приложении.

• Info (20): этот уровень предназначен для вывода данных о фрагментах кода, работающих так, как ожидается.

• Warning (30): этот уровень логирования предусматривает вывод предупреждений, он применяется для записи сведений о событиях, на которые программист обычно обращает внимание. Такие события вполне могут привести к проблемам при работе приложения. Если явно не задать уровень логирования — по умолчанию используется именно warning.

• Error (40): этот уровень логирования предусматривает вывод сведений об ошибках — о том, что часть приложения работает не так как ожидается, о том, что программа не смогла правильно выполниться.

• Critical (50): этот уровень используется для вывода сведений об очень серьёзных ошибках, наличие которых угрожает нормальному функционированию всего приложения. Если не исправить такую ошибку — это может привести к тому, что приложение прекратит работу.

В следующем фрагменте кода показано использование вышеперечисленных уровней логирования при выводе нескольких сообщений. Здесь используется синтаксическая конструкция logging.<level>(<message>).

logging.debug("A DEBUG Message")
logging.info("An INFO")
logging.warning("A WARNING")
logging.error("An ERROR")
logging.critical("A message of CRITICAL severity")

Ниже приведён результат выполнения этого кода. Как видите, сообщения, выведенные с уровнями логирования warning, error и critical, попадают в консоль. А сообщения с уровнями debug и info — не попадают.

WARNING:root:A WARNING
ERROR:root:An ERROR
CRITICAL:root:A message of CRITICAL severity

Это так из-за того, что в консоль выводятся лишь сообщения с уровнями от warning и выше. Но это можно изменить, настроив логгер и указав ему, что в консоль надо выводить сообщения, начиная с некоего, заданного вами, уровня логирования.

Подобный подход к логированию, когда данные выводятся в консоль, не особо лучше использования print(). На практике может понадобиться записывать логируемые сообщения в файл. Этот файл будет хранить данные и после того, как работа программы завершится. Такой файл можно использовать в качестве журнала отладки.

Обратите внимание на то, что в примере, который мы будем тут разбирать, весь код находится в файле main.py. Когда мы производим рефакторинг существующего кода или добавляем новые модули — мы сообщаем о том, в какой файл (имя которого построено по схеме <module-name>.py) попадает новый код. Это поможет вам воспроизвести у себя то, о чём тут идёт речь.

Логирование в файл

Для того чтобы настроить простую систему логирования в файл — можно воспользоваться конструктором basicConfig(). Вот как это выглядит:

logging.basicConfig(level=logging.INFO, filename="py_log.log",filemode="w")
logging.debug("A DEBUG Message")
logging.info("An INFO")
logging.warning("A WARNING")
logging.error("An ERROR")
logging.critical("A message of CRITICAL severity")

Поговорим о логгере root, рассмотрим параметры basicConfig():

• level: это — уровень, на котором нужно начинать логирование. Если он установлен в info — это значит, что все сообщения с уровнем debug игнорируются.

• filename: этот параметр указывает на объект обработчика файла. Тут можно указать имя файла, в который нужно осуществлять логирование.

• filemode: это — необязательный параметр, указывающий режим, в котором предполагается работать с файлом журнала, заданным параметром filename. Установка filemode в значение w (write, запись) приводит к тому, что логи перезаписываются при каждом запуске модуля. По умолчанию параметр filemode установлен в значение a (append, присоединение), то есть — в файл будут попадать записи из всех сеансов работы программы.

После выполнения модуля main можно будет увидеть, что в текущей рабочей директории был создан файл журнала, py_log.log.

Так как мы установили уровень логирования в значение info — в файл попадут записи с уровнем info и с более высокими уровнями.

Записи в лог-файле имеют формат <logging-level>:<name-of-the-logger>:<message>. По умолчанию <name-of-the-logger>, имя логгера, установлено в root, так как мы пока не настраивали пользовательские логгеры.

Помимо базовой информации, выводимой в лог, может понадобится снабдить записи отметками времени, указывающими на момент вывода той или иной записи. Это упрощает анализ логов. Сделать это можно, воспользовавшись параметром конструктора format:

logging.basicConfig(level=logging.INFO, filename="py_log.log",filemode="w",
                    format="%(asctime)s %(levelname)s %(message)s")
logging.debug("A DEBUG Message")
logging.info("An INFO")
logging.warning("A WARNING")
logging.error("An ERROR")
logging.critical("A message of CRITICAL severity")

Существуют и многие другие атрибуты записи лога, которыми можно воспользоваться для того чтобы настроить внешний вид сообщений в лог-файле. Настраивая поведение логгера root — так, как это показано выше, проследите за тем, чтобы конструктор logging.basicConfig()вызывался бы лишь один раз. Обычно это делается в начале программы, до использования команд логирования. Последующие вызовы конструктора ничего не изменят — если только не установить параметр force в значение True.

Логирование значений переменных и исключений

Модифицируем файл main.py. Скажем — тут будут две переменных — x и y, и нам нужно вычислить значение выражения x/y. Мы знаем о том, что при y=0 мы столкнёмся с ошибкой ZeroDivisionError. Обработать эту ошибку можно в виде исключения с использованием блока try/except.

Далее — нужно залогировать исключение вместе с данными трассировки стека. Чтобы это сделать — можно воспользоваться logging.error(message, exc_info=True). Запустите следующий код и посмотрите на то, как в файл попадают записи с уровнем логирования info, указывающие на то, что код работает так, как ожидается.

x = 3
y = 4

logging.info(f"The values of x and y are {x} and {y}.")
try:
    x/y
    logging.info(f"x/y successful with result: {x/y}.")
except ZeroDivisionError as err:
    logging.error("ZeroDivisionError",exc_info=True)

Теперь установите значение y в 0 и снова запустите модуль.

Исследуя лог-файл py_log.log, вы увидите, что сведения об исключении были записаны в него вместе со стек-трейсом.

x = 4
y = 0

logging.info(f"The values of x and y are {x} and {y}.")
try:
    x/y
    logging.info(f"x/y successful with result: {x/y}.")
except ZeroDivisionError as err:
    logging.error("ZeroDivisionError",exc_info=True)

Теперь модифицируем код так, чтобы в нём имелись бы списки значений x и y, для которых нужно вычислить коэффициенты x/y. Для логирования исключений ещё можно воспользоваться конструкцией logging.exception(<message>).

x_vals = [2,3,6,4,10]
y_vals = [5,7,12,0,1]

for x_val,y_val in zip(x_vals,y_vals):
    x,y = x_val,y_val
    logging.info(f"The values of x and y are {x} and {y}.")
    try:
        x/y
        logging.info(f"x/y successful with result: {x/y}.")
    except ZeroDivisionError as err:
        logging.exception("ZeroDivisionError")

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

Настройка логирования с помощью пользовательских логгеров, обработчиков и форматировщиков

Отрефакторим код, который у нас уже есть. Объявим функцию test_division.

def test_division(x,y):
    try:
        x/y
        logger2.info(f"x/y successful with result: {x/y}.")
    except ZeroDivisionError as err:
        logger2.exception("ZeroDivisionError")

Объявление этой функции находится в модуле test_div. В модуле main будут лишь вызовы функций. Настроим пользовательские логгеры в модулях main и test_div, проиллюстрировав это примерами кода.

Настройка пользовательского логгера для модуля test_div

import logging

logger2 = logging.getLogger(__name__)
logger2.setLevel(logging.INFO)

# настройка обработчика и форматировщика для logger2
handler2 = logging.FileHandler(f"{__name__}.log", mode='w')
formatter2 = logging.Formatter("%(name)s %(asctime)s %(levelname)s %(message)s")

# добавление форматировщика к обработчику
handler2.setFormatter(formatter2)
# добавление обработчика к логгеру
logger2.addHandler(handler2)

logger2.info(f"Testing the custom logger for module {__name__}...")

def test_division(x,y):
    try:
        x/y
        logger2.info(f"x/y successful with result: {x/y}.")
    except ZeroDivisionError as err:
        logger2.exception("ZeroDivisionError")

Настройка пользовательского логгера для модуля main

import logging
from test_div import test_division 

# получение пользовательского логгера и установка уровня логирования
py_logger = logging.getLogger(__name__)
py_logger.setLevel(logging.INFO)

# настройка обработчика и форматировщика в соответствии с нашими нуждами
py_handler = logging.FileHandler(f"{__name__}.log", mode='w')
py_formatter = logging.Formatter("%(name)s %(asctime)s %(levelname)s %(message)s")

# добавление форматировщика к обработчику 
py_handler.setFormatter(py_formatter)
# добавление обработчика к логгеру
py_logger.addHandler(py_handler)

py_logger.info(f"Testing the custom logger for module {__name__}...")

x_vals = [2,3,6,4,10]
y_vals = [5,7,12,0,1]

for x_val,y_val in zip(x_vals,y_vals):
    x,y = x_val, y_val
    # вызов test_division
    test_division(x,y)
    py_logger.info(f"Call test_division with args {x} and {y}")

Разберёмся с тем, что происходит коде, где настраиваются пользовательские логгеры.

Сначала мы получаем логгер и задаём уровень логирования. Команда logging.getLogger(name) возвращает логгер с заданным именем в том случае, если он существует. В противном случае она создаёт логгер с заданным именем. На практике имя логгера устанавливают с использованием специальной переменной name, которая соответствует имени модуля. Мы назначаем объект логгера переменной. Затем мы, используя команду logging.setLevel(level), устанавливаем нужный нам уровень логирования.

Далее мы настраиваем обработчик. Так как мы хотим записывать сведения о событиях в файл, мы пользуемся FileHandler. Конструкция logging.FileHandler(filename) возвращает объект обработчика файла. Помимо имени лог-файла, можно, что необязательно, задать режим работы с этим файлом. В данном примере режим (mode) установлен в значение write. Есть и другие обработчики, например — StreamHandler, HTTPHandler, SMTPHandler.

Затем мы создаём объект форматировщика, используя конструкцию logging.Formatter(format). В этом примере мы помещаем имя логгера (строку) в начале форматной строки, а потом идёт то, чем мы уже пользовались ранее при оформлении сообщений.

Потом мы добавляем форматировщик к обработчику, пользуясь конструкцией вида <handler>.setFormatter(<formatter>). А в итоге добавляем обработчик к объекту логгера, пользуясь конструкцией <logger>.addHandler(<handler>).

Теперь можно запустить модуль main и исследовать сгенерированные лог-файлы.

Рекомендации по организации логирования в Python

До сих пор мы говорили о том, как логировать значения переменных и исключения, как настраивать пользовательские логгеры. Теперь же предлагаю вашему вниманию рекомендации по логированию.

• Устанавливайте оптимальный уровень логирования. Логи полезны лишь тогда, когда их можно использовать для отслеживания важных ошибок, которые нужно исправлять. Подберите такой уровень логирования, который соответствует специфике конкретного приложения. Вывод в лог сообщений о слишком большом количестве событий может быть, с точки зрения отладки, не самой удачной стратегией. Дело в том, что при таком подходе возникнут сложности с фильтрацией логов при поиске ошибок, которым нужно немедленно уделить внимание.

• Конфигурируйте логгеры на уровне модуля. Когда вы работаете над приложением, состоящим из множества модулей — вам стоит задуматься о том, чтобы настроить свой логгер для каждого модуля. Установка имени логгера в name помогает идентифицировать модуль приложения, в котором имеются проблемы, нуждающиеся в решении.

• Включайте в состав сообщений логов отметку времени и обеспечьте единообразное форматирование сообщений. Всегда включайте в сообщения логов отметки времени, так как они полезны в деле поиска того момента, когда произошла ошибка. Единообразно форматируйте сообщения логов, придерживаясь одного и того же подхода в разных модулях.

• Применяйте ротацию лог-файлов ради упрощения отладки. При работе над большим приложением, в состав которого входит несколько модулей, вы, вполне вероятно, столкнётесь с тем, что размер ваших лог-файлов окажется очень большим. Очень длинные логи сложно просматривать в поисках ошибок. Поэтому стоит подумать о ротации лог-файлов. Сделать это можно, воспользовавшись обработчиком RotatingFileHandler, применив конструкцию, которая строится по следующей схеме: logging.handlers.RotatingFileHandler(filename, maxBytes, backupCount). Когда размер текущего лог-файла достигнет размера maxBytes, следующие записи будут попадать в другие файлы, количество которых зависит от значения параметра backupCount. Если установить этот параметр в значение K — у вас будет K файлов журнала.

Сильные и слабые стороны логирования

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

Мы уже видели, как логирование позволяет поддерживать файлы журналов для различных модулей, из которых состоит приложение. Мы, кроме того, можем конфигурировать подсистему логирования и подстраивать её под свои нужды. Но эта система не лишена недостатков. Даже когда уровень логирования устанавливают в значение warning, или в любое значение, которое выше warning, размеры лог-файлов способны быстро увеличиваться. Происходит это в том случае, когда в один и тот же журнал пишут данные, полученные после нескольких сеансов работы с приложением. В результате использование лог-файлов для отладки программ превращается в нетривиальную задачу.

Кроме того, исследование логов ошибок — это сложно, особенно в том случае, если сообщения об ошибках не содержат достаточных сведений о контекстах, в которых происходят ошибки. Когда выполняют команду logging.error(message), не устанавливая при этом exc_info в True, сложно обнаружить и исследовать первопричину ошибки в том случае, если сообщение об ошибке не слишком информативно.

В то время как логирование даёт диагностическую информацию, сообщает о том, что в приложении нужно исправить, инструменты для мониторинга приложений, вроде Sentry, могут предоставить более детальную информацию, которая способна помочь в диагностике приложения и в исправлении проблем с производительностью.

В следующем разделе мы поговорим о том, как интегрировать в Python-проект поддержку Sentry, что позволит упростить процесс отладки кода.

Интеграция Sentry в Python-проект

Установить Sentry Python SDK можно, воспользовавшись менеджером пакетов pip.

pip install sentry-sdk

После установки SDK для настройки мониторинга приложения нужно воспользоваться таким кодом:

sentry_sdk.init(
     dsn="<your-dsn-key-here>",
     traces_sample_rate=0.85,
)

Как можно видеть — вам, для настройки мониторинга, понадобится ключ dsn. DSN расшифровывается как Data Source Name (имя источника данных). Найти этот ключ можно, перейдя в Your-Project > Settings > Client Keys (DSN).

После того, как вы запустите Python-приложение, вы можете перейти на Sentry.io и открыть панель управления проекта. Там должны быть сведения о залогированных ошибках и о других проблемах приложения. В нашем примере можно видеть сообщение об исключении, соответствующем ошибке ZeroDivisionError.

Изучая подробности об ошибке, вы можете увидеть, что Sentry предоставляет подробную информацию о том, где именно произошла ошибка, а так же — об аргументах x и y, работа с которыми привела к появлению исключения.

Продолжая изучение логов, можно увидеть, помимо записей уровня error, записи уровня info. Налаживая мониторинг приложения с использованием Sentry, нужно учитывать, что эта платформа интегрирована с модулем logging. Вспомните — в нашем экспериментальном проекте уровень логирования был установлен в значение info. В результате Sentry записывает все события, уровень которых соответствует info и более высоким уровням, делая это в стиле «навигационной цепочки», что упрощает отслеживание ошибок.

Sentry позволяет фильтровать записи по уровням логирования, таким, как info и error. Это удобнее, чем просмотр больших лог-файлов в поиске потенциальных ошибок и сопутствующих сведений. Это позволяет назначать решению проблем приоритеты, зависящие от серьёзности этих проблем, и, кроме того, позволяет, используя навигационные цепочки, находить источники неполадок.

В данном примере мы рассматриваем ZeroDivisionError как исключение. В более крупных проектах, даже если мы не реализуем подобный механизм обработки исключений, Sentry автоматически предоставит диагностическую информацию о наличии необработанных исключений. С помощью Sentry, кроме того, можно анализировать проблемы с производительностью кода.

Код, использованный в данном руководстве, можно найти в этом GitHub-репозитории.

Итоги

Освоив это руководство, вы узнали о том, как настраивать логирование с использованием стандартного Python-модуля logging. Вы освоили основы настройки логгера root и пользовательских логгеров, ознакомились с рекомендациями по логированию. Вы, кроме того, узнали о том, как платформа Sentry может помочь вам в деле мониторинга ваших приложений, обеспечивая вас сведениями о проблемах с производительностью и о других ошибках, и используя при этом все возможности модуля logging.

Когда вы будете работать над своим следующим Python-проектом — не забудьте реализовать в нём механизмы логирования. И можете испытать бесплатную пробную версию Sentry.

О, а приходите к нам работать? 🤗 💰

В этом руководстве мы изучим основы стандартного модуля логирования в Python.

Logging в Python- это модуль в стандартной библиотеке, который обеспечивает возможность работы со средой для выпуска сообщений журнала из программ Python. Логирование используется для отслеживания событий, происходящих при запуске программного обеспечения.

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

Каким-то образом мы обнаруживаем причину сбоя, но на ее устранение уйдет много времени. Используя ведение журнала, мы можем оставить “следы”, чтобы, если проблема возникла в программе, мы могли легко найти причину проблемы.

Как работает регистрация

Logging – мощный модуль, используемый как новичками, так и профессионалами. Этот модуль обеспечивает навыки для организации различных обработчиков элементов управления и передачи сообщений журнала этим обработчикам.

Чтобы выпустить сообщение журнала, нам нужно импортировать модуль ведения журнала следующим образом.

 
import logging  

Теперь мы вызовем средство логирования, чтобы записывать сообщения, которые мы хотим видеть. Модуль регистрации предлагает пять уровней, определяющих серьезность событий. Каждое событие содержит параллельные методы, которые можно использовать для регистрации событий на уровне серьезности. Давайте разберемся в следующих событиях и их работе.

1. ОТЛАДКА – используется для предоставления подробной информации и использования ее только при диагностике проблем.
2. ИНФОРМАЦИЯ – предоставляет информацию о том, что все работает так, как мы хотим.
3. ПРЕДУПРЕЖДЕНИЕ – используется, чтобы предупредить, что что-то произошло неожиданно, или мы столкнемся с проблемой в ближайшее время.
4. ОШИБКА – используется, чтобы сообщить, когда у нас возникли серьезные проблемы, что программное обеспечение не выполнило некоторые программы.
5. КРИТИЧЕСКАЯ ОШИБКА – указывает на серьезную ошибку, сама программа может не работать.

Вышеуказанных уровней достаточно для решения любых проблем. Соответствующие числовые значения уровней приведены ниже.

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

Давайте посмотрим на несколько объектов регистратора, предлагаемых самим модулем.

• Logger.info(msg): используется для регистрации сообщения с уровнем INFO в этом регистраторе.
• Logger.warning(msg): используется для регистрации сообщения с уровнем WARNING.
• Logger.error(msg): используется для уровня ERROR.
• Logger.critical(msg): регистрация уровня CRITICAL на этом регистраторе.
• Logger.log(lvl, msg):  для записи сообщения с целочисленным уровнем lvl.
• Logger.exception(msg): для сообщения с уровнем ERROR на этом регистраторе.
• Logger.setLevel(lvl): необходим для установки начала этого регистратора на lvl. Он проигнорирует все сообщения, написанные ниже.
• Logger.addFilter(filter): используется для добавления определенного фильтра filter к этому регистратору.
• Logger.removeFilter(filter): используется для удаления определенного фильтра filter.
• Logger.filter(запись): ставит фильтр регистратора на запись. Если запись доступна и подлежит обработке, возвращается True. В противном случае он вернет False.
• Logger.addHandler(hdlr): используется для добавления определенного обработчика hdlr к этому регистратору.
• Logger.removeHandler(hdlr): необходим для исключения определенного обработчика hdlr.
• Logger.hasHandlers():нужен для проверки того, содержит ли регистратор какой-либо настроенный обработчик или нет.

Давайте разберемся в следующем примере.

 
import logging 
 
logging.debug('The debug message is displaying') 
logging.info('The info message is displaying') 
logging.warning('The warning message is displaying') 
logging.error('The error message is displaying') 
logging.critical('The critical message is displaying') 

Выход:

WARNING:root:The warning message is displaying 
ERROR:root:The error message is displaying 
CRITICAL:root:The critical message is displaying  

Объяснение:

Как видно из вышеприведенного вывода, каждое сообщение отображается вместе с корнем, который представляет собой имя модуля ведения журнала, присвоенное его регистратору по умолчанию. Сообщение и имя уровня разделяются двоеточием(:) и печатают сообщения в формате вывода по умолчанию.

Мы можем заметить, что сообщения debug() и info() не отображали сообщения, потому что по умолчанию модуль журнала регистрирует сообщения с уровнем серьезности WARNING, ERROR и CRITICAL.

Базовые конфигурации

Основная задача логирования – хранить записи событий в файле. Модуль предоставляет basicConfig(** kwarg), используемый для настройки ведения журнала.

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

• level – указанный уровень серьезности устанавливается корневым уровнем;
• filename – указывает файл;
• filemode – открывает файл в определенном режиме. Режим открытия файла по умолчанию – a, что означает, что мы можем добавлять содержимое;
• format – формат определяет формат сообщения журнала.

Мы можем установить уровень сообщений журнала, используя параметр уровня, который мы хотим записывать. Нам нужно передать одну константу в класс, которая разрешила бы все вызовы логирования.

Пример –

 
import logging 
 
logging.basicConfig(level=logging.DEBUG) 
logging.debug('The dubug message is logged') 

Выход:

 
DEBUG:root: The debug will be get logged 

Точно так же мы можем записывать сообщение в файл вместо отображения на консоли, имя файла и режим файла могут использоваться в функции basicConfig(), и мы можем определять формат сообщения с помощью атрибутов формата. Давайте разберемся в следующем примере.

 
import logging 
 
logging.basicConfig(filename='msg.log', filemode='w', format='%(name)s - %(levelname)s - %(message)s') 
logging.warning('This will get logged to a file') 

Выход:

 
root - WARNING - This will get logged to a file 

Объяснение:

Приведенный выше вывод будет отображаться в файле msg.log вместо консоли. Мы открыли файл в w, что означает, что файл открыт в «режиме записи». Если basicConfig() вызывается несколько раз, то каждый запуск программы будет перезаписывать вывод файла журнала. Функцию basicConfig() можно изменить, передав дополнительные аргументы https://docs.python.org/3/library/logging.html#logging.basicConfig.

Пример –

 
import logging 
 
#Create and configure logger using the basicConfig() function 
logging.basicConfig(filename="newfile.log", 
               format='%(asctime)s %(message)s', 
               filemode='w') 
 
#Creating an object of the logging 
logger=logging.getLogger() 
 
#Setting the threshold of logger to DEBUG 
logger.setLevel(logging.DEBUG) 
 
#Test messages 
logger.debug("This is a harmless debug Message") 
logger.info("This is just an information") 
logger.warning("It is a Warning. Please make changes") 
logger.error("You are trying to divide by zero") 
logger.critical("Internet is down")  

Выход:

2020-09-05 13:17:39,204 This is a harmless debug Message 
2020-09-05 13:17:39,205 This is just an information 
2020-09-05 13:17:39,205 It is a Warning. Please make changes 
2020-09-05 13:17:39,205 You are trying to divide by zero 
2020-09-05 13:17:39,205 Internet is down 

Объяснение:

Приведенный выше код сгенерирует файл, и мы сможем увидеть результат при открытии файла.

Форматирование вывода

Строка, переданная в программе как сообщение для журнала, может быть изменена в соответствии с нашими требованиями. В данной строке и части Logrecord есть несколько основных элементов. Давайте разберемся в следующем примере.

 
import logging 
 
logging.basicConfig(format='%(process)d-%(levelname)s-%(message)s') 
logging.warning('This is a Warning Message') 

Выход:

18472-WARNING-This is a Warning Message 

Аргумент формата может принимать строку с атрибутами Logrecord в любой форме, которая нам требуется.

Пример –

 
import logging 
 
logging.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO) 
logging.info('Admin logged in') 

Выход:

2020-09-02 20:12:06,288 - Admin logged in 

Атрибуты%(asctime) добавляют время создания записи журнала. Мы также можем настроить формат с помощью атрибутов datefmt, которые предоставляют ту же функцию, что и модуль datetime.

Пример –

 
import logging 
 
logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S') 
logging.warning('Admin logged out') 

Выход:

02-Sep-20 13:29:05 - Admin logged out 

Регистрация переменных данных

Иногда мы хотим включить динамическую информацию из приложения в журнал. Методы ведения журнала принимают строку в качестве аргумента, и рекомендуется отформатировать строку с помощью переменных данных и передать ее методу журнала.

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

Давайте разберемся в следующем примере –

 
import logging 
 
name = 'Peter Decosta' 
 
logging.error('%s raised an error', name) 

Выход:

ERROR:root: Peter Decosta raised an error 

Объяснение:

Аргументы, переданные методу, будут свернуты как переменные данные в сообщении.

Мы можем использовать f {string} для форматирования данной строки. Он обеспечивает короткий и простой способ обращения со строкой.

Пример –

 
import logging 
 
name = 'Antonio Mino' 
 
logging.error(f'{name} raised an error') 

Выход:

ERROR:root: Antonio Mino raised an error 

Отслеживание трассировки стека

Мы можем фиксировать полные стеки трассировок в приложении с помощью модуля регистрации. В функции ведения журнала есть параметр exc_info; если мы установим его как True, он может захватывать информацию об исключении.

Пример –

 
import logging 
 
a = 10 
b = 0 
 
try: 
  c = a / b 
except Exception as e: 
  logging.error("Exception occurred", exc_info=True) 

Выход:

ERROR:root:Exception occurred 
Traceback(most recent call last): 
  File "C:/Users/DEVANSH SHARMA/PycharmProjects/Hello/loggingFile.py", line 224, in <module>
    c = a / b 
ZeroDivisionError: division by zero 

Объяснение:

Если мы не установим значение exc_info в true, выходные данные не будут сообщать нам об исключении. Было бы сложно отладить ошибку в тысячах строк кода, если она отображает только следующий вывод.

 
ERROR:root:Exception occurred 

Есть также другой способ получить полную информацию об исключении. Модуль регистрации предоставляет метод exception(), который регистрирует сообщение с ERROR и прикрепляет информацию об исключении. Чтобы использовать его, вызовите метод logging.exception() так же, как вызов logging.error(exc_info = True).

Пример –

 
import logging 
 
a = 10 
b = 0 
 
try: 
  c = a / b 
except Exception as e: 
  logging.exception("Exception occurred", exc_info=True) 

Выход:

ERROR:root:Exception occurred 
Traceback(most recent call last): 
  File "C:/Users/DEVANSH SHARMA/PycharmProjects/Hello/loggingFile.py", line 224, in  <module>
    c = a / b 
ZeroDivisionError: division by zero 

Мы можем использовать любую из опций в методах error(), debug() или critical(), чтобы получить информацию об исключении.

Классы и функции

До сих пор мы видели регистратор по умолчанию с именем root. Модуль ведения журнала используется всякий раз, когда вызываются его функции, такие как logging.debug(), logging.error() и т. д. Мы также можем определить собственное средство ведения журнала, создав объект класса Logger. Здесь мы определяем обычно используемые классы и функции.

Ниже приведены классы и функции, определенные в модуле logging.

• Регистратор – объект регистратора используется для прямого вызова функций.
• LogRecord – он автоматически создает файл записи журнала, который содержит информацию, относящуюся ко всем регистрируемым событиям, такую как имя регистратора, функция, номер строки, сообщение и многое другое.
• Обработчик – обработчики используются для отправки LogRecord в конечную точку вывода. FileHandler, StreamHandler, HTTPHandler, SMTTPHandler являются подклассами обработчика.
• Средства форматирования – средства форматирования используются для определения структуры вывода. Для указания формата сообщений журнала используются методы форматирования строк.

Если у нас нет сообщения для форматирования, по умолчанию используется необработанное сообщение. Формат даты по умолчанию –

 
%Y-%m-%d %H:%M:%S 

Следующий формат используется для создания сообщения журнала в удобочитаемом формате.

 
'%(asctime)s - %(levelname)s - %(message)s' 

Обычно мы работаем с объектами класса Logger, которые создаются с помощью функции logging.getLogger(name). Если метод getLogger() вызывается несколько раз с одним и тем же именем, он вернет ссылку на один и тот же объект регистратора.

Давайте разберемся в следующем примере:

Пример –

 
import logging 
 
logger = logging.getLogger('first_logger') 
logger.warning('This is a warning message') 

Выход:

This is a warning message 

Объяснение:

Мы создали собственное имя регистратора first_logger, но, в отличие от корневого регистратора, first_logger не является частью выходного формата. Чтобы отобразить его, передайте его в функцию конфигурации. Тогда результат будет выглядеть следующим образом.

 
WARNING:first_logger:This is a warning message 

Работа с обработчиками

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

Давайте разберемся в следующем примере создания обработчиков.

Пример:

 
import logging 
 
# Create a custom logger_obj 
logger_obj = logging.getLogger(__name__) 
 
# Create handlers 
w_handler = logging.StreamHandler() 
e_handler = logging.FileHandler('file.log') 
w_handler.setLevel(logging.WARNING) 
e_handler.setLevel(logging.ERROR) 
 
# Create formatters and add it to handlers 
c_format = logging.Formatter('%(name)s - %(levelname)s - %(message)s') 
f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') 
w_handler.setFormatter(c_format) 
e_handler.setFormatter(f_format) 
 
# Add handlers to the logger_obj 
logger_obj.addHandler(w_handler) 
logger_obj.addHandler(e_handler) 
 
logger_obj.warning('This is a warning message') 
logger_obj.error('This is an error message') 

Выход:

__main__ - WARNING - This is a warning message 
__main__ - ERROR - This is an error message 

Объяснение:

В следующей программе мы создали настраиваемый регистратор с именем logger_obj и создали LogRecord, который хранит всю запись событий регистрации и передает ее всем имеющимся обработчикам: w_handlers и e_handlers.

W_handlers – это обработчик потока с уровнем WARNING. Он принимает журнал из LogRecord для генерации вывода в строке формата и вывода его на экран.

E_handler – это обработчик файлов с уровнем ERROR. Он игнорирует LogRecord как его уровень ПРЕДУПРЕЖДЕНИЕ.

Заключение

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

Он также обеспечивает базовое ведение журнала для небольших проектов. В этом руководстве мы обсудили все основные концепции модуля logging. Мы рассмотрели создание сообщений с разными уровнями.

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Logging in Python

Logging is a very useful tool in a programmer’s toolbox. It can help you develop a better understanding of the flow of a program and discover scenarios that you might not even have thought of while developing.

Logs provide developers with an extra set of eyes that are constantly looking at the flow that an application is going through. They can store information, like which user or IP accessed the application. If an error occurs, then they can provide more insights than a stack trace by telling you what the state of the program was before it arrived at the line of code where the error occurred.

By logging useful data from the right places, you can not only debug errors easily but also use the data to analyze the performance of the application to plan for scaling or look at usage patterns to plan for marketing.

Python provides a logging system as a part of its standard library, so you can quickly add logging to your application. In this article, you will learn why using this module is the best way to add logging to your application as well as how to get started quickly, and you will get an introduction to some of the advanced features available.

import logging

logging.debug('This is a debug message')
logging.info('This is an info message')
logging.warning('This is a warning message')
logging.error('This is an error message')
logging.critical('This is a critical message')

WARNING:root:This is a warning message
ERROR:root:This is an error message
CRITICAL:root:This is a critical message

import logging

logging.basicConfig(level=logging.DEBUG)
logging.debug('This will get logged')

DEBUG:root:This will get logged

import logging

logging.basicConfig(filename='app.log', filemode='w', format='%(name)s - %(levelname)s - %(message)s')
logging.warning('This will get logged to a file')

root - ERROR - This will get logged to a file

ERROR:root:This is an error message

import logging

logging.basicConfig(format='%(process)d-%(levelname)s-%(message)s')
logging.warning('This is a Warning')

18472-WARNING-This is a Warning

import logging

logging.basicConfig(format='%(asctime)s - %(message)s', level=logging.INFO)
logging.info('Admin logged in')

2018-07-11 20:12:06,288 - Admin logged in

import logging

logging.basicConfig(format='%(asctime)s - %(message)s', datefmt='%d-%b-%y %H:%M:%S')
logging.warning('Admin logged out')

12-Jul-18 20:53:19 - Admin logged out

import logging

name = 'John'

logging.error('%s raised an error', name)

ERROR:root:John raised an error

import logging

name = 'John'

logging.error(f'{name} raised an error')

ERROR:root:John raised an error

import logging

a = 5
b = 0

try:
  c = a / b
except Exception as e:
  logging.error("Exception occurred", exc_info=True)

ERROR:root:Exception occurred
Traceback (most recent call last):
  File "exceptions.py", line 6, in <module>
    c = a / b
ZeroDivisionError: division by zero
[Finished in 0.2s]

ERROR:root:Exception occurred

import logging

a = 5
b = 0
try:
  c = a / b
except Exception as e:
  logging.exception("Exception occurred")

ERROR:root:Exception occurred
Traceback (most recent call last):
  File "exceptions.py", line 6, in <module>
    c = a / b
ZeroDivisionError: division by zero
[Finished in 0.2s]

import logging

logger = logging.getLogger('example_logger')
logger.warning('This is a warning')

WARNING:example_logger:This is a warning

# logging_example.py

import logging

# Create a custom logger
logger = logging.getLogger(__name__)

# Create handlers
c_handler = logging.StreamHandler()
f_handler = logging.FileHandler('file.log')
c_handler.setLevel(logging.WARNING)
f_handler.setLevel(logging.ERROR)

# Create formatters and add it to handlers
c_format = logging.Formatter('%(name)s - %(levelname)s - %(message)s')
f_format = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
c_handler.setFormatter(c_format)
f_handler.setFormatter(f_format)

# Add handlers to the logger
logger.addHandler(c_handler)
logger.addHandler(f_handler)

logger.warning('This is a warning')
logger.error('This is an error')

__main__ - WARNING - This is a warning
__main__ - ERROR - This is an error

2018-08-03 16:12:21,723 - __main__ - ERROR - This is an error

# run.py

import logging_example

logging_example - WARNING - This is a warning
logging_example - ERROR - This is an error

[loggers]
keys=root,sampleLogger

[handlers]
keys=consoleHandler

[formatters]
keys=sampleFormatter

[logger_root]
level=DEBUG
handlers=consoleHandler

[logger_sampleLogger]
level=DEBUG
handlers=consoleHandler
qualname=sampleLogger
propagate=0

[handler_consoleHandler]
class=StreamHandler
level=DEBUG
formatter=sampleFormatter
args=(sys.stdout,)

[formatter_sampleFormatter]
format=%(asctime)s - %(name)s - %(levelname)s - %(message)s

import logging
import logging.config

logging.config.fileConfig(fname='file.conf', disable_existing_loggers=False)

# Get the logger specified in the file
logger = logging.getLogger(__name__)

logger.debug('This is a debug message')

2018-07-13 13:57:45,467 - __main__ - DEBUG - This is a debug message

version: 1
formatters:
  simple:
    format: '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
handlers:
  console:
    class: logging.StreamHandler
    level: DEBUG
    formatter: simple
    stream: ext://sys.stdout
loggers:
  sampleLogger:
    level: DEBUG
    handlers: [console]
    propagate: no
root:
  level: DEBUG
  handlers: [console]

import logging
import logging.config
import yaml

with open('config.yaml', 'r') as f:
    config = yaml.safe_load(f.read())
    logging.config.dictConfig(config)

logger = logging.getLogger(__name__)

logger.debug('This is a debug message')

2018-07-13 14:05:03,766 - __main__ - DEBUG - This is a debug message

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Logging in Python