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)