Logging Avançado e Monitoramento de Aplicações Python

O logging é essencial para rastrear o comportamento de aplicações, diagnosticar problemas e monitorar performance em ambientes de produção. Python possui o módulo nativo logging, mas técnicas avançadas envolvem configuração estruturada, logging assíncrono, métricas e integração com sistemas externos.

---

1. Conceitos Fundamentais de Logging

1.1 Níveis de Log

• DEBUG → informações detalhadas para diagnóstico

• INFO → eventos gerais de funcionamento

• WARNING → situações inesperadas, mas sem impacto crítico

• ERROR → falhas que afetam a execução de uma função

• CRITICAL → falhas graves que podem parar o sistema

import logging

logging.basicConfig(level=logging.INFO)
logging.debug("Debug detalhado")
logging.info("Mensagem informativa")
logging.warning("Aviso")
logging.error("Erro ocorreu")
logging.critical("Falha crítica")

---

1.2 Loggers, Handlers e Formatters

• Logger: interface principal para emitir logs

• Handler: define onde os logs serão enviados (console, arquivo, socket)

• Formatter: define o formato do log

logger = logging.getLogger("app_logger")
logger.setLevel(logging.DEBUG)

fh = logging.FileHandler("app.log")
ch = logging.StreamHandler()

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setFormatter(formatter)
ch.setFormatter(formatter)

logger.addHandler(fh)
logger.addHandler(ch)

• Permite logs direcionados a múltiplos destinos com formatos diferentes.

---

2. Logging Avançado

2.1 Rotação de Arquivos (File Rotation)

• Evita que arquivos de log cresçam indefinidamente.

from logging.handlers import RotatingFileHandler

handler = RotatingFileHandler("app.log", maxBytes=5*1024*1024, backupCount=3)
handler.setFormatter(formatter)
logger.addHandler(handler)

• maxBytes define o tamanho máximo do arquivo

• backupCount define quantos arquivos antigos manter

---

2.2 Logging Assíncrono

• Evita bloqueio da aplicação durante escrita de logs em I/O pesado

import logging
import queue
import threading
from logging.handlers import QueueHandler, QueueListener

log_queue = queue.Queue(-1)
queue_handler = QueueHandler(log_queue)
logger.addHandler(queue_handler)

file_handler = logging.FileHandler("async.log")
listener = QueueListener(log_queue, file_handler)
listener.start()

logger.info("Log assíncrono")
listener.stop()

• Útil em aplicações multithread ou asyncio, evitando travamentos.

---

2.3 Logs Estruturados e JSON

• Facilita integração com sistemas de monitoramento como ELK, Graylog ou Splunk

import json
import logging

class JsonFormatter(logging.Formatter):
    def format(self, record):
        log_record = {
            "time": record.asctime,
            "level": record.levelname,
            "name": record.name,
            "message": record.getMessage()
        }
        return json.dumps(log_record)

handler.setFormatter(JsonFormatter())

• Permite query e análise automatizada de logs.

---

2.4 Contextualização de Logs

• Adiciona informações úteis, como ID de requisição, usuário ou sessão.

logger = logging.getLogger("app")
extra = {"user_id": 123, "request_id": "abc"}
logger = logging.LoggerAdapter(logger, extra)
logger.info("Processamento iniciado")

• Mantém logs mais claros e rastreáveis em sistemas distribuídos.

---

3. Monitoramento de Aplicações

3.1 Métricas em Tempo Real

• Integração com Prometheus usando prometheus_client:

from prometheus_client import start_http_server, Counter

c = Counter("requests_total", "Total de requisições")

start_http_server(8000)

def handle_request():
    c.inc()

• Permite monitorar métricas customizadas em dashboards Grafana.

3.2 Logging e Tracing Distribuído

• Para sistemas distribuídos ou microservices, usar OpenTelemetry:

from opentelemetry import trace

tracer = trace.get_tracer(__name__)
with tracer.start_as_current_span("processamento"):
    logger.info("Operação rastreada")

• Combina logs e rastreabilidade de requisições.

---

3.3 Alertas Automáticos

• Logs podem disparar alertas em Slack, Teams ou email:

from logging.handlers import SMTPHandler

smtp_handler = SMTPHandler(mailhost=("smtp.exemplo.com", 587),
                           fromaddr="app@exemplo.com",
                           toaddrs=["ops@exemplo.com"],
                           subject="Erro crítico")
smtp_handler.setLevel(logging.ERROR)
logger.addHandler(smtp_handler)

• Permite notificação imediata de falhas críticas.

---

4. Boas Práticas Profissionais

1. Configure loggers por módulo, evitando logs duplicados.

2. Use log levels adequados: DEBUG para desenvolvimento, INFO/ERROR para produção.

3. Combine log rotation e logging assíncrono para sistemas de alta carga.

4. Utilize logs estruturados para integração com ferramentas externas.

5. Inclua informações de contexto (usuário, requisição, sessão).

6. Monitore métricas e logs em dashboards, habilitando alertas para falhas críticas.

7. Evite print() em produção; sempre use logging estruturado.

---

5. Aplicações Profissionais

• Sistemas web e APIs (monitoramento de requisições e erros)

• Aplicações financeiras ou científicas (rastreamento de processamento)

• Microservices distribuídos (tracing e métricas)

• ETL e pipelines de dados (logs assíncronos e métricas)

• Sistemas de IoT e monitoramento remoto

---

6. Conclusão

• Logging avançado e monitoramento permitem detecção rápida de problemas, análise de performance e rastreabilidade.

• Técnicas avançadas incluem:

  • Logging assíncrono e rotativo

  • Logs estruturados em JSON

  • Contextualização e tracing distribuído

  • Integração com Prometheus, Grafana e alertas automáticos

• Seguindo boas práticas, é possível criar aplicações Python escaláveis, confiáveis e facilmente monitoráveis.