Capítulo 3: Logging com SLF4J

Introdução

System.out.println() é bom para depuração, mas em produção é inutilizável. SLF4J com Logback oferece um sistema de logging profissional.

---

🎯 Objetivos do Capítulo

Ao final deste capítulo, você saberá:

1. ✅ Utilizar SLF4J em suas classes
2. ✅ Compreender os níveis de log
3. ✅ Escrever logs eficazes
4. ✅ Utilizar o MDC para rastreabilidade
5. ✅ Evitar erros comuns

---

1. SLF4J: A Fachada de Logging

Arquitetura

Seu código
    ↓
SLF4J (API/Fachada)
    ↓
Logback (Implementação)
    ↓
Console / Arquivo / Cloud

Vantagem: Troque a implementação sem modificar o código.

Spring Boot inclui por padrão

<!-- Já incluído no spring-boot-starter -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
</dependency>
<!-- Contém: spring-boot-starter-logging (SLF4J + Logback) -->

---

2. Criando um Logger

Método Clássico

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@Service
public class UserService {

    private static final Logger log = LoggerFactory.getLogger(UserService.class);

    public User findById(Long id) {
        log.info("Finding user with ID: {}", id);
        return userRepository.findById(id).orElse(null);
    }
}

Com Lombok @Slf4j (Recomendado)

import lombok.extern.slf4j.Slf4j;

@Slf4j  // ← Gera automaticamente o logger
@Service
public class UserService {

    public User findById(Long id) {
        log.info("Finding user with ID: {}", id);
        return userRepository.findById(id).orElse(null);
    }
}

---

3. Níveis de Log

Hierarquia (do menos ao mais crítico)

TRACE → DEBUG → INFO → WARN → ERROR

Nível	Uso	Exemplo
TRACE	Detalhes muito finos	"Entering method X with params..."
DEBUG	Informações de debug	"Calculated value: 42"
INFO	Eventos normais	"User logged in", "Order created"
WARN	Possíveis problemas	"Cache miss", "Retrying connection"
ERROR	Erros	"Failed to save", "Connection refused"

Utilização

@Slf4j
@Service
public class OrderService {

    public Order processOrder(Order order) {
        log.trace("Entering processOrder with order: {}", order);
        
        log.debug("Validating order items: {} items", order.getItems().size());
        
        log.info("Processing order {} for user {}", order.getId(), order.getUserId());
        
        if (order.getTotal() > 10000) {
            log.warn("Large order detected: {} - Total: {}", order.getId(), order.getTotal());
        }
        
        try {
            return saveOrder(order);
        } catch (Exception e) {
            log.error("Failed to process order {}: {}", order.getId(), e.getMessage(), e);
            throw e;
        }
    }
}

---

4. Boas Práticas de Logging

✅ Use Placeholders

// ✅ BOM: Placeholders (melhor performance)
log.debug("Processing user {} with email {}", userId, email);

// ❌ RUIM: Concatenação (sempre avaliada)
log.debug("Processing user " + userId + " with email " + email);

✅ Logar Exceções Corretamente

try {
    riskyOperation();
} catch (Exception e) {
    // ✅ BOM: Exceção como último parâmetro (exibe stack trace)
    log.error("Operation failed for user {}: {}", userId, e.getMessage(), e);
    
    // ❌ RUIM: Sem stack trace
    log.error("Operation failed: " + e.getMessage());
    
    // ❌ RUIM: e.printStackTrace() ao invés de logar
    e.printStackTrace();
}

✅ Logs Úteis e Contextuais

// ✅ BOM: Contexto suficiente
log.info("Order {} created for user {} - Total: {} - Items: {}", 
    order.getId(), order.getUserId(), order.getTotal(), order.getItems().size());

// ❌ RUIM: Sem contexto
log.info("Order created");

// ❌ RUIM: Muito verboso
log.info("Created order object with ID " + order.getId() + " and this order was created by user with ID " + order.getUserId() + "...");

✅ Evite Log Spam

// ❌ RUIM: Log dentro de um loop
for (Item item : items) {
    log.debug("Processing item: {}", item);  // 1000 logs se 1000 items!
}

// ✅ BOM: Log resumido
log.debug("Processing {} items", items.size());
for (Item item : items) {
    // processamento...
}
log.debug("Finished processing items");

---

5. Verificação de Nível

Para Operações Custosas

// Se o cálculo é custoso, verifique o nível antes
if (log.isDebugEnabled()) {
    String expensiveDetails = calculateExpensiveDetails(order);
    log.debug("Order details: {}", expensiveDetails);
}

// Alternativa com Java 8 Supplier (Logback 1.3+)
log.atDebug()
    .addArgument(() -> calculateExpensiveDetails(order))
    .log("Order details: {}");

---

6. MDC (Mapped Diagnostic Context)

O que é o MDC?

O MDC permite adicionar contexto a todos os logs de uma requisição (userId, requestId, etc.).

Uso Básico

import org.slf4j.MDC;

@Component
public class LoggingFilter implements Filter {

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        
        try {
            // Adicionar contexto
            MDC.put("requestId", UUID.randomUUID().toString());
            MDC.put("userId", getCurrentUserId());
            
            chain.doFilter(request, response);
        } finally {
            // IMPORTANTE: Sempre limpe!
            MDC.clear();
        }
    }
}

Resultado nos Logs

2024-01-15 10:30:00 [requestId=abc-123] [userId=42] INFO  OrderService - Processing order
2024-01-15 10:30:01 [requestId=abc-123] [userId=42] INFO  PaymentService - Payment processed
2024-01-15 10:30:01 [requestId=abc-123] [userId=42] INFO  EmailService - Confirmation sent

Filter Completo com MDC

@Component
@Order(Ordered.HIGHEST_PRECEDENCE)
public class MdcLoggingFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                     HttpServletResponse response, 
                                     FilterChain filterChain) 
            throws ServletException, IOException {
        
        try {
            // Request ID
            String requestId = request.getHeader("X-Request-ID");
            if (requestId == null) {
                requestId = UUID.randomUUID().toString().substring(0, 8);
            }
            MDC.put("requestId", requestId);
            
            // User ID (se autenticado)
            Authentication auth = SecurityContextHolder.getContext().getAuthentication();
            if (auth != null && auth.isAuthenticated()) {
                MDC.put("userId", auth.getName());
            }
            
            // Path
            MDC.put("path", request.getRequestURI());
            
            // Adicionar o requestId na resposta
            response.setHeader("X-Request-ID", requestId);
            
            filterChain.doFilter(request, response);
            
        } finally {
            MDC.clear();
        }
    }
}

---

7. Logging nas Diferentes Camadas

Controller

@Slf4j
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    @PostMapping
    public ResponseEntity<Order> create(@RequestBody OrderRequest request) {
        log.info("Received order creation request: {} items", request.getItems().size());
        
        Order order = orderService.create(request);
        
        log.info("Order {} created successfully", order.getId());
        return ResponseEntity.status(HttpStatus.CREATED).body(order);
    }
}

Service

@Slf4j
@Service
public class OrderService {

    public Order create(OrderRequest request) {
        log.debug("Creating order for user {}", request.getUserId());
        
        // Validação
        validateItems(request.getItems());
        
        // Cálculo
        BigDecimal total = calculateTotal(request.getItems());
        log.debug("Calculated total: {}", total);
        
        // Salvando
        Order order = orderRepository.save(toOrder(request, total));
        
        log.info("Order {} saved with total {}", order.getId(), total);
        return order;
    }
}

Repository (opcional)

// Os logs do JPA/Hibernate geralmente são suficientes
// Mas para queries customizadas:

@Slf4j
@Repository
public class CustomOrderRepository {

    public List<Order> findComplexQuery(Criteria criteria) {
        log.debug("Executing complex query with criteria: {}", criteria);
        
        List<Order> results = executeQuery(criteria);
        
        log.debug("Query returned {} results", results.size());
        return results;
    }
}

---

8. Configuração Rápida

application.properties

# Nível global
logging.level.root=INFO

# Nível por pacote
logging.level.com.myapp=DEBUG
logging.level.com.myapp.repository=TRACE

# Exibir queries SQL
logging.level.org.hibernate.SQL=DEBUG
logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE

# Desabilitar logs ruidosos
logging.level.org.apache.catalina=WARN
logging.level.org.springframework.web=INFO

Níveis Recomendados

Ambiente	Root	Aplicação	Hibernate
Dev	INFO	DEBUG	DEBUG
Test	WARN	INFO	WARN
Prod	WARN	INFO	WARN

---

9. Resumo

Criar um Logger

// Com Lombok (recomendado)
@Slf4j
public class MyClass {
    void method() {
        log.info("Message");
    }
}

// Sem Lombok
private static final Logger log = LoggerFactory.getLogger(MyClass.class);

Níveis

TRACE < DEBUG < INFO < WARN < ERROR

Boas Práticas

// Placeholders
log.info("User {} logged in", userId);

// Exceção com stack trace
log.error("Failed: {}", e.getMessage(), e);

// MDC para contexto
MDC.put("requestId", "abc-123");

---

🎯 Próximo Passo

Você já sabe fazer logging. Agora, vamos configurar o Logback para controlar onde e como os logs são gravados.

➡️ Capítulo 4: Configuração Logback

---

⬅️ Voltar ao Módulo 10