Введение: Боль и страдания от print() и стандартного logging

Если вы пишете на Python, скорее всего, ваша карьера разработчика начиналась с одной простой, но незаменимой команды — print(). Нужно проверить значение переменной? print(my_variable). Хотите убедиться, что функция вообще вызвалась? print("Я внутри функции!"). Этот метод прост, интуитивно понятен и кажется верным другом в мире отладки.

Но дружба эта длится ровно до первого серьезного проекта. Внезапно оказывается, что ваш терминал завален десятками отладочных сообщений, и вы уже не понимаете, какое из них к чему относится. Вы начинаете писать print("--- HERE ---"), чтобы хоть как-то ориентироваться в этом хаосе. А когда приходит время выкатывать код в продакшен, вы судорожно ищете и комментируете все свои print(), надеясь не пропустить ни одного.

В этот момент опытные коллеги (или статьи в интернете) говорят вам: "Для этого есть стандартный модуль logging!". И они правы. logging — это мощный, гибкий и правильный инструмент. Но давайте будем честны, его настройка часто напоминает бюрократическую процедуру. Чтобы просто начать писать логи в файл с указанием времени и уровня, нужно написать что-то вроде этого:

import logging

# Настройка... снова и снова
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[
        logging.FileHandler("debug.log"),
        logging.StreamHandler()
    ]
)

logging.info("Пользователь вошел в систему.")
logging.warning("Не удалось найти файл конфигурации.")

Это работает, но это громоздко. Пять-шесть строк кода только для того, чтобы начать. А если вам понадобится ротация файлов, кастомные форматы или что-то посложнее? Конфигурация становится еще запутаннее.

Именно в этот момент на сцену выходит Loguru. Эта библиотека была создана для того, чтобы избавить нас от страданий. Она берет лучшее из двух миров: феноменальную простоту print() и всю мощь взрослого логирования, но без лишнего "шума" и сложной настройки.

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

В этой статье мы раз и навсегда забудем про print() для отладки и посмотрим, как Loguru может сделать ваше логирование не только мощным, но и по-настоящему красивым и удобным.

Часть 1: Первое знакомство с Loguru — магия "из коробки"

Итак, мы оставили позади боль от print() и сложность logging. Давайте посмотрим, что предлагает Loguru и почему его называют "логированием для удовольствия".

Установка: один шаг до магии

Как и положено современному Python-пакету, установка предельно проста и выполняется одной командой в терминале:

pip install loguru

Всё, библиотека готова к работе. Никаких зависимостей, никаких сложных настроек окружения.

"Hello, Loguru!": начинаем за 5 секунд

Помните, сколько кода нужно было для базовой настройки logging? Забудьте. С Loguru вы просто импортируете готовый к использованию объект logger и начинаете его использовать.

from loguru import logger

logger.info("Hello, Loguru!")
logger.warning("Это предупреждение, будьте внимательны.")
logger.debug("Это сообщение не будет видно по умолчанию.")

Запустите этот код, и вы увидите в консоли что-то вроде этого:

2025-11-13 13:00:00.000 | INFO     | __main__:__main__:3 - Hello, Loguru!
2025-11-13 13:00:00.000 | WARNING  | __main__:__main__:4 - Это предупреждение, будьте внимательны.

Обратите внимание: debug-сообщение не появилось. По умолчанию Loguru, как и любая серьезная система логирования, показывает сообщения уровня INFO и выше. Это правильное поведение, которое избавляет от лишнего шума в консоли.

Разбираем стандартный вывод: всё, что нужно, и ничего лишнего

Давайте внимательно посмотрим на первую строку вывода:

2025-11-13 13:00:00.000 | INFO | __main__:__main__:3 - Hello, Loguru!

Даже без единой строчки конфигурации Loguru сразу предоставляет нам богатый контекст:

• Дата и время: 2025-11-13 13:00:00.000 — точная временная метка, когда произошло событие. Больше не нужно гадать, к какому моменту времени относится print.

• Уровень лога: INFO — показывает важность сообщения. WARNING говорит о потенциальной проблеме, ERROR — о серьезной ошибке.

• Местоположение: __main__:__main__:3 — это самая полезная часть. Loguru автоматически указывает имя файла, функцию и номер строки, откуда был сделан вызов. Это невероятно ускоряет отладку!

• Сообщение: Hello, Loguru! — непосредственно то, что мы хотели записать.

Магия цвета: прощай, монотонная консоль!

Если вы запустите приведенный выше код в терминале, который поддерживает цвета (а сегодня это делают почти все), вы увидите еще одну приятную особенность: вывод будет раскрашен!

• INFO обычным белым.

• WARNING — заметным желтым.

• ERROR и CRITICAL — тревожно-красным.

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

Всего один import — и мы уже получили цветное, информативное и правильно структурированное логирование. Это и есть магия Loguru "из коробки". А ведь мы еще даже не начали знакомиться с его основными возможностями

Часть 2: Основные возможности на практических примерах

Мы убедились, что Loguru прекрасен "из коробки". Но его настоящая сила раскрывается, когда мы начинаем использовать его основные функции. И здесь Loguru остается верен своему принципу: максимум пользы при минимуме кода.

Уровни логирования: управляем потоком информации

Как мы уже видели, Loguru поддерживает стандартные уровни важности сообщений:

• TRACE (самый подробный)

• DEBUG

• INFO

• SUCCESS (приятное дополнение для успешных операций)

• WARNING

• ERROR

• CRITICAL

По умолчанию в консоль выводятся сообщения от INFO и выше. Это легко изменить. Например, чтобы включить DEBUG-сообщения, нужно перенастроить стандартный обработчик (sink), указав новый уровень:

from loguru import logger
import sys # sys нужен для sys.stderr

# Удаляем стандартный обработчик...
logger.remove()
# ...и добавляем новый с уровнем DEBUG.
# ВНИМАНИЕ: это также сбросит формат вывода к самому простому.
# О том, как настроить свой красивый формат, мы поговорим в Части 3.
logger.add(sys.stderr, level="DEBUG")

logger.debug("Теперь это сообщение будет видно!")
logger.info("И это, конечно, тоже.")

Запись логов в файл: одна строка, чтобы править всеми

Это одна из самых мощных и востребованных функций. Забудьте про FileHandler и его сложную настройку. С Loguru все делается одной командой — logger.add().

Просто записать в файл:

from loguru import logger

logger.add("my_app.log")

logger.info("Это сообщение попадет и в консоль, и в файл my_app.log")

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

Автоматическая ротация файлов (Rotation)

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

# Создавать новый файл, как только текущий достигнет 500 MB
logger.add("big_file.log", rotation="500 MB")

# Создавать новый файл каждую неделю
logger.add("weekly_log.log", rotation="1 week")

# Создавать новый файл каждый день в полночь
logger.add("daily_log.log", rotation="00:00")

Автоматическая очистка старых логов (Retention)

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

# Хранить логи за последние 10 дней
logger.add("cleaned_log.log", retention="10 days")

Автоматическое сжатие (Compression)

Loguru может даже самостоятельно архивировать старые лог-файлы, чтобы они занимали меньше места.

# При ротации сжимать старые файлы в zip-архив
logger.add("compressed_log.log", rotation="10 MB", compression="zip")

Давайте соберем все вместе в один мощный пример для реального проекта:

from loguru import logger

# Настраиваем логирование для продакшена:
# - Пишем в файл `prod.log`
# - Уровень - INFO и выше
# - Ротация при достижении 10 MB
# - Храним файлы 1 месяц
# - Сжимаем старые логи в .gz
logger.add("prod.log", level="INFO", rotation="10 MB", retention="1 month", compression="gz")

logger.info("Система запущена и готова к работе!")

Всего одна строка кода заменяет десятки строк конфигурации стандартного logging. Это невероятно удобно.

Форматирование в стиле f-string

Еще одна мелочь, которая делает жизнь разработчика проще. Loguru использует для форматирования строк фигурные скобки, как в f-strings, что гораздо читабельнее и привычнее, чем старый %-стиль.

user_id = 123
status = "success"

# Привычный и читаемый синтаксис
logger.info("Аутентификация для пользователя {id} прошла со статусом: {status}", id=user_id, status=status)

Вывод будет таким:
... | INFO | ... - Аутентификация для пользователя 123 прошла со статусом: success

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

Часть 3: Продвинутые техники для настоящих профи

Мы освоили основы, которые уже делают работу с логами приятнее. Но Loguru был создан не только для удобства — он предоставляет мощнейшие инструменты для отладки, которые могут сэкономить вам часы поиска ошибок. Давайте рассмотрим функции, которые отличают новичка от профессионала.

1. Идеальная отладка исключений

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

Логирование внутри try...except

Во-первых, вы можете использовать logger.exception(), который автоматически захватит и красиво отформатирует информацию о последнем исключении.

from loguru import logger

try:
    result = 10 / 0
except ZeroDivisionError:
    logger.exception("Произошла ошибка при вычислении.")

Вывод будет содержать не только ваше сообщение, но и полный, аккуратно отформатированный трейсбэк ошибки.

Декоратор @logger.catch — ваша секретная кнопка "Найти ошибку"

Но настоящий прорыв — это декоратор @logger.catch. Вы можете просто "обернуть" в него любую функцию, и Loguru автоматически поймает любое исключение, которое в ней произойдет, и выведет самый подробный отчет из возможных.

Посмотрите на этот пример:

from loguru import logger

@logger.catch
def calculate(a, b, c):
    return a / b + c

calculate(10, 0, 5) # Эта строка вызовет ошибку

Без @logger.catch вы бы получили стандартный трейсбэк. Но с декоратором Loguru выведет в консоль нечто гораздо более ценное:

> 2025-11-13 13:00:00.000 | ERROR    | __main__:calculate:5 - An error has been caught in function 'calculate', process 'MainProcess' (1234), thread 'MainThread' (5678):
Traceback (most recent call last):
...
  File "my_script.py", line 6, in <module>
    calculate(10, 0, 5)
    │         │  │  └ c = 5
    │         │  └ b = 0
    │         └ a = 10
  File "my_script.py", line 5, in calculate
    return a / b + c
           ──┘ └───
            │   └ 0
            └ 10

ZeroDivisionError: division by zero

Посмотрите внимательно: Loguru не просто показал, где произошла ошибка, он показал значения всех аргументов (a = 10, b = 0, c = 5) в момент падения! Это бесценная информация для отладки, которую вы получаете, добавив всего одну строку кода (@logger.catch).

2. Кастомизация формата логов

Стандартный формат хорош, но иногда его нужно адаптировать. Это легко сделать с помощью параметра format в logger.add(). Но здесь кроется важный нюанс, связанный с цветами.

Магия цвета Loguru работает благодаря специальным тегам, похожим на HTML, которые встроены в стандартный формат. Главный из них — это тег <level>. Именно он говорит Loguru раскрасить текст в цвет, соответствующий уровню сообщения.

Давайте посмотрим, что произойдет, если мы зададим простой формат без этих тегов:

from loguru import logger
import sys

logger.remove()

# Добавляем простой формат БЕЗ тегов
logger.add(sys.stderr, colorize=True, format="{time:HH:mm:ss} | {level} | {message}")

logger.info("Информационное сообщение.")
logger.warning("Сообщение с предупреждением.")
logger.error("Сообщение об ошибке.")

Запустив этот код, вы заметите, что цветное выделение уровней (INFO, WARNING) пропало или стало другим. Параметр colorize=True попытается раскрасить всю строку целиком, что часто выглядит менее эффектно и может быть незаметно для некоторых уровней.

Чтобы вернуть "умное" раскрашивание, нужно использовать теги в строке формата.

Вы можете собрать свой идеальный формат из готовых "кирпичиков":

# Удаляем предыдущий обработчик
logger.remove()

# Создаем свой, очень подробный формат с тегами
custom_format = (
    "<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | "
    "<level>{level: <8}</level> | " # <level> отвечает за цвет уровня
    "<cyan>{name}</cyan>:<cyan>{function}</cyan> - <level>{message}</level>" # и здесь тоже
)

logger.add(sys.stderr, format=custom_format, colorize=True)

logger.info("Лог в кастомном, снова цветном формате.")

Здесь мы не просто указали поля ({time}, {level}), но и обернули их в теги:

• <green>...</green> — всегда будет красить текст в зеленый.

• <level>...</level> — будет красить текст в цвет, соответствующий уровню лога.

Теперь вы полностью контролируете внешний вид логов, сохраняя при этом их читаемость. Полный список доступных полей есть в официальной документации Loguru.

3. Структурированное логирование (JSON)

В современных системах логи часто собираются и анализируются машинами (например, в ELK Stack, Graylog или Datadog). Для этого они должны быть в структурированном формате, чаще всего — JSON.

С Loguru это делается элементарно — добавлением одного параметра: serialize=True.

from loguru import logger

logger.add("structured_data.log", serialize=True)

user_data = {"id": 123, "name": "John Doe"}
logger.info("Пользователь {user} обновил профиль", user=user_data)

В файле structured_data.log появится запись в формате JSON, идеально подходящая для парсинга:

{
    "text": "Пользователь {'id': 123, 'name': 'John Doe'} обновил профиль\n",
    "record": {
        "elapsed": {"repr": "0:00:00.001000", "seconds": 0.001},
        "exception": null,
        "extra": {},
        "file": {"name": "my_script.py", "path": "/path/to/my_script.py"},
        "function": "<module>",
        "level": {"icon": "ℹ️", "name": "INFO", "no": 20},
        "line": 6,
        "message": "Пользователь {'id': 123, 'name': 'John Doe'} обновил профиль",
        "name": "__main__",
        "process": {"id": 1234, "name": "MainProcess"},
        "thread": {"id": 5678, "name": "MainThread"},
        "time": {"repr": "2025-11-13T13:00:00.000000+03:00", "timestamp": 1762989600.0}
    }
}

4. Добавление контекста с помощью bind()

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

from loguru import logger
import uuid

# Создаем логгер с привязанным ID запроса
request_id = str(uuid.uuid4())
context_logger = logger.bind(request_id=request_id)

context_logger.info("Получен новый запрос.")
# ... какой-то код
context_logger.info("Данные из базы успешно получены.")
# ... еще код
context_logger.warning("Внешний API ответил с задержкой.")

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

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

Часть 4: Loguru в реальном проекте: Советы и лучшие практики

Мы изучили мощные функции Loguru, но как грамотно внедрить его в полноценное приложение? Просто импортировать logger в каждом файле — это начало, но для создания надежной и масштабируемой системы стоит следовать нескольким профессиональным практикам.

1. Центральная конфигурация: один файл, чтобы править всеми

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

Часто в разработке нам нужен один тип логов (подробные, цветные, в консоли), а на продакшене — совсем другой (в JSON-файлы, с ротацией, менее подробные). Давайте реализуем этот подход.

Создайте файл app/logging_config.py:

# app/logging_config.py
import sys
import os
from loguru import logger

def setup_logging():
    """
    Настраивает логгер для всего приложения в зависимости от окружения.
    """
    # Удаляем стандартный обработчик, чтобы избежать дублирования
    logger.remove()

    # Определяем формат для консоли (разработка)
    dev_format = (
        "<green>{time:HH:mm:ss.SSS}</green> | "
        "<level>{level: <8}</level> | "
        "<cyan>{name}</cyan>:<cyan>{function}</cyan> - <level>{message}</level>"
    )

    # Определяем формат для файла (продакшен)
    prod_format = "{time:YYYY-MM-DD HH:mm:ss} | {level} | {name}:{function} | {message}"

    # Конфигурация для разработки (если не указано иное)
    if os.getenv("ENV_TYPE", "dev") == "dev":
        logger.add(sys.stderr, level="DEBUG", format=dev_format, colorize=True)
        logger.info("Режим разработки: логирование настроено для вывода в консоль.")

    # Конфигурация для продакшена
    else:
        # В консоль выводим только важные сообщения
        logger.add(sys.stderr, level="INFO", format=prod_format, colorize=False)
        
        # В файл пишем все, начиная с DEBUG, в формате JSON для машинного анализа
        logger.add(
            "logs/app.log",
            level="DEBUG",
            rotation="10 MB",
            retention="1 month",
            compression="zip",
            serialize=True,  # Структурированное логирование в JSON
        )
        logger.info("Режим продакшена: логирование настроено для вывода в консоль и файл.")

Теперь в главном файле вашего приложения main.py достаточно вызвать эту функцию один раз при старте:

# main.py
from app.logging_config import setup_logging
from loguru import logger

# Вызываем настройку в самом начале работы приложения
setup_logging()

@logger.catch
def main_logic():
    logger.info("Приложение начинает работу.")
    logger.debug("Это отладочное сообщение, которое не попадет в прод-консоль, но попадет в прод-файл.")
    # ... ваш основной код ...

if __name__ == "__main__":
    main_logic()

Теперь вы можете управлять логированием, просто установив переменную окружения ENV_TYPE=prod при запуске вашего приложения на сервере.

2. Приручаем "чужие" логи: интеграция со стандартным logging

Ваш проект почти наверняка использует сторонние библиотеки (requests, SQLAlchemy, uvicorn), которые работают со стандартным модулем logging. По умолчанию их сообщения не попадут в Loguru. Но мы можем это исправить.

Loguru может "перехватить" все сообщения из logging и направить их в свои обработчики. Для этого в ваш конфигурационный файл нужно добавить специальный класс-обработчик. Этот код — готовый рецепт, который можно просто скопировать.

Дополним наш app/logging_config.py:

# ... (в начале файла app/logging_config.py)
import logging

# ... (сам класс можно разместить перед функцией setup_logging)
class InterceptHandler(logging.Handler):
    def emit(self, record):
        try:
            level = logger.level(record.levelname).name
        except ValueError:
            level = record.levelno

        frame, depth = logging.currentframe(), 2
        while frame.f_code.co_filename == logging.__file__:
            frame = frame.f_back
            depth += 1

        logger.opt(depth=depth, exception=record.exc_info).log(level, record.getMessage())

# ... (а эту часть добавьте ВНУТРЬ функции setup_logging)
def setup_logging():
    # ... (код для logger.remove() и logger.add() остается здесь) ...

    # Настраиваем перехват логов из стандартного logging
    logging.basicConfig(handlers=[InterceptHandler()], level=0, force=True)
    logger.info("Стандартный logging перехвачен и направлен в Loguru.")

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

3. Безопасность в продакшене: не раскрывайте свои секреты!

Это самый важный совет в этой части. Декоратор @logger.catch и функция logger.exception() — невероятно мощные инструменты для отладки, так как они показывают значения переменных в момент ошибки.

Но в продакшене это может привести к катастрофической утечке данных! Если в переменных окажутся пароли, ключи API или персональные данные пользователей, они попадут прямо в логи.

Правило для продакшена: всегда отключайте диагностику.

# НЕ ДЕЛАЙТЕ ТАК В ПРОДАКШЕНЕ
@logger.catch
def process_user_data(user, password):
    # ...

# ДЕЛАЙТЕ ТАК В ПРОДАКШЕНЕ
@logger.catch(diagnose=False, reraise=True) # reraise=True чтобы ошибка не была "съедена"
def process_user_data(user, password):
    # ...

То же самое касается и ручной обработки исключений:

try:
    # ... critical code ...
except Exception as e:
    # diagnose=False отключает показ переменных
    logger.opt(exception=e, diagnose=False).error("Произошла критическая ошибка в модуле X")

4. Производительность: асинхронность и многопоточность

• Потокобезопасность: Loguru потокобезопасен "из коробки". Вы можете без опасений использовать его в многопоточных приложениях.

• Асинхронность и высокая нагрузка: В асинхронных (asyncio) или очень нагруженных приложениях стандартная запись в файл может стать "бутылочным горлышком", замедляя работу основной программы. Чтобы этого избежать, используйте параметр enqueue=True.

  logger.add("high_load_app.log", enqueue=True)
  

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

Домашнее задание: Закрепляем Loguru на практике

Прочитав статью, вы узнали, как сделать логирование в Python удобным и мощным. Теперь давайте применим эти знания на практике! Нажмите на каждую задачу, чтобы раскрыть её условие.

Анонс новых статей, полезные материалы, а так же если в процессе решения возникнут сложности, обсудить их или задать вопрос по статье можно в моём Telegram-сообществе.

Уверен, у вас все получится. Вперед, к практике!