SLF4J - Quick Reference

When to Use This Skill

Standard logging API for Java
Integration with Logback, Log4j2
Java logging best practices

Deep Knowledge: Use mcp__documentation__fetch_docs with technology: slf4j for comprehensive documentation.

Essential Patterns

Logger Declaration

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

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

    // Or with Lombok
    // @Slf4j on class
}

Logging Levels

log.trace("Detailed debug info: {}", details);
log.debug("Debug info for development");
log.info("Normal operation: user {} logged in", userId);
log.warn("Potential problem: {} retries remaining", retries);
log.error("Error occurred: {}", message, exception);

Parameterized Logging

// Good - lazy evaluation
log.debug("Processing order {} for user {}", orderId, userId);

// Avoid - always evaluates
log.debug("Processing order " + orderId + " for user " + userId);

// Multiple parameters
log.info("User {} performed {} on resource {}", userId, action, resourceId);

Exception Logging

try {
    processOrder(order);
} catch (OrderException e) {
    // Exception is always last parameter
    log.error("Failed to process order {}: {}", order.getId(), e.getMessage(), e);
}

MDC (Mapped Diagnostic Context)

import org.slf4j.MDC;

// Set context
MDC.put("requestId", requestId);
MDC.put("userId", userId);

try {
    // All logs in this scope will include requestId and userId
    log.info("Processing request");
} finally {
    MDC.clear();
}

Conditional Logging

if (log.isDebugEnabled()) {
    log.debug("Expensive computation result: {}", expensiveMethod());
}

// Better with lambdas (SLF4J 2.0+)
log.atDebug().log(() -> "Result: " + expensiveMethod());

Fluent API (SLF4J 2.0+)

log.atInfo()
   .addKeyValue("orderId", orderId)
   .addKeyValue("amount", amount)
   .log("Order processed successfully");

When NOT to Use This Skill

Logging framework configuration: Use logback or Log4j2 skills for XML/config
Performance tuning: Configuration-level optimization is in implementation skills
Transport/appender setup: That's implementation-specific (Logback/Log4j2)
Non-Java projects: Use language-appropriate logging APIs
Direct implementation usage: Always code to SLF4J API, not Logback/Log4j2 directly

Anti-Patterns

Anti-Pattern	Why It's Bad	Solution
String concatenation in logs	Always evaluated, performance hit	Use parameterized logging: `log.info("User {}", id)`
Logging without level check for expensive ops	Wastes CPU even when disabled	Use `if (log.isDebugEnabled())` before expensive calls
Catching exceptions without logging	Silent failures, hard to debug	Always log with `log.error("msg", exception)`
Not using MDC for request context	Loses correlation across logs	Use `MDC.put()` with try-finally
Using wrong log level	Too much noise or missing issues	Follow conventions: ERROR=requires action, WARN=potential issue
Logging sensitive data	Security/compliance violation	Mask PII, passwords, tokens before logging

Quick Troubleshooting

Issue	Cause	Solution
NoClassDefFoundError: StaticLoggerBinder	No SLF4J implementation on classpath	Add Logback or Log4j2 dependency
Multiple bindings warning	Multiple SLF4J implementations	Keep only one: Logback OR Log4j2
Logs not appearing	Wrong log level	Check implementation config (logback.xml)
Parameters not replaced	Wrong placeholder syntax	Use `{}` not `%s` or other formats
MDC values empty	MDC cleared or wrong thread	Ensure MDC.put() before logging, clear in finally
Exception stack trace missing	Exception not last parameter	Put exception as last param: `log.error("msg", e)`