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)