Simplify Python Logging with Loguru: From Boilerplate to Best Practices

Why Python logging feels painful?

Configuring Python logging can involve many moving parts—handlers, formatters, levels, and configuration files—making it feel like assembling IKEA furniture without instructions, often leading to broken setups.

1. Too much boilerplate

import logging
from logging.handlers import RotatingFileHandler
logger = logging.getLogger('MyApp')
handler = logging.StreamHandler()
file_handler = RotatingFileHandler('app.log', maxBytes=5*1024*1024, backupCount=10)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
logger.addHandler(handler)
logger.addHandler(file_handler)
logger.setLevel(logging.DEBUG)

Writing all this code can waste valuable development time.

2. Cryptic error messages

Missing a handler or formatter often results in silent failures, leaving developers guessing why logs are absent.

3. Confusing log levels

Although DEBUG, INFO, WARNING, ERROR, and CRITICAL sound simple, developers frequently disagree on their exact meanings, leading to inconsistent usage.

Rescue tool: Loguru

Loguru is a third‑party library that makes Python logging extremely simple.

Minimal configuration

from loguru import logger
logger.add("logs/app.log", level="DEBUG", format="{time:YYYY-MM-DD HH:mm:ss} - {level} - {file} - {line} - {message}", rotation="10 MB")
logger.info('可以写日志了')

One line adds a rotating file handler; no explicit handlers or folders are required.

Error tracing made easy

from loguru import logger

@logger.catch
def test():
    'a' + 1

test()

The decorator automatically captures exceptions and prints a detailed traceback with variable values, dramatically improving debugging speed.

Why Loguru is a lifesaver?

1. Ready out of the box

Import the library and start logging; the same logger works across all modules without additional setup.

from loguru import logger
logger.info('直接使用，无需额外配置')

2. Powerful features

Automatic log rotation : prevents log files from growing indefinitely.

Exception catching : a decorator records uncaught exceptions automatically.

Color support : colored console output makes logs easier to read.

Asynchronous logging : logging does not block the main program.

3. Structured logging

logger.info("用户操作", user_id=123, action="login", success=True)

Structured entries are easier for downstream log analysis tools to query.

Can standard logging be rescued?

Create a reusable logger helper

import logging, os

def setup_logger(name=None, level=logging.INFO):
    """Create and return a configured logger."""
    logger = logging.getLogger(name or __name__)
    logger.setLevel(level)
    if not logger.handlers:
        console = logging.StreamHandler()
        console.setLevel(level)
        os.makedirs('logs', exist_ok=True)
        file_handler = logging.handlers.RotatingFileHandler(
            'logs/app.log', maxBytes=5*1024*1024, backupCount=3, encoding='utf-8')
        file_handler.setLevel(level)
        formatter = logging.Formatter(
            '%(asctime)s - [%(levelname)s] - %(name)s - %(filename)s:%(lineno)d - %(message)s',
            datefmt='%Y-%m-%d %H:%M:%S')
        console.setFormatter(formatter)
        file_handler.setFormatter(formatter)
        logger.addHandler(console)
        logger.addHandler(file_handler)
    return logger

logger = setup_logger("my_app")
logger.info("日志变得简单了！")

This helper can be imported anywhere in the project to ensure consistent logging configuration.

Practical scenarios

Web development (FastAPI)

from fastapi import FastAPI
from loguru import logger

app = FastAPI()

@app.middleware("http")
async def log_requests(request, call_next):
    logger.info(f"请求: {request.method} {request.url}")
    response = await call_next(request)
    logger.info(f"响应: {response.status_code}")
    return response

@app.get("/")
async def read_root():
    logger.info("访问根路径")
    return {"Hello": "World"}

Data processing progress tracking

from loguru import logger

def process_data(data):
    total = len(data)
    for i, item in enumerate(data):
        if i % 100 == 0:
            logger.info(f"进度: {i}/{total} ({i/total*100:.1f}%)")
        logger.debug(f"处理项目: {item}")
    logger.success(f"数据处理完成，共处理 {total} 条记录")

Script debugging

from loguru import logger

@logger.catch
def main():
    logger.info("脚本开始执行")
    # your code here
    logger.info("脚本执行完成")

if __name__ == "__main__":
    main()

Logging best practices

1. Choose appropriate level

DEBUG : detailed debugging information, use in development.

INFO : confirm normal operation.

WARNING : indicate potential or minor issues.

ERROR : serious problems that affect functionality.

CRITICAL : fatal errors that prevent the program from continuing.

2. Include context information

# Bad
logger.error("操作失败")
# Good
logger.error("用户操作失败", user_id=user_id, action=action, reason=error_msg)

3. Consider performance in production

if logger.isEnabledFor(logging.DEBUG):
    expensive_data = generate_expensive_debug_data()
    logger.debug("数据: %s", expensive_data)

Conclusion

Whether you adopt Loguru or wrap the standard logging module with a helper, Python logging can become simple, consistent, and powerful, enabling rapid issue localisation and efficient debugging in backend projects.