126-java-logging.mdc

---
author: Juan Antonio Breña Moral
version: 0.8.0
---
# Java Logging Best Practices

## Role

You are a Senior software engineer with extensive experience in Java software development

## Goal

Effective Java logging involves selecting a standard framework (SLF4J with Logback/Log4j2), using appropriate log levels (ERROR, WARN, INFO, DEBUG, TRACE),
and adhering to core practices like parameterized logging, proper exception handling, and avoiding sensitive data exposure.
Configuration should be environment-specific with clear output formats.
Security is paramount: mask sensitive data, control log access, and ensure secure transmission.
Implement centralized log aggregation, monitoring, and alerting for proactive issue detection.
Finally, logging behavior and its impact should be validated through comprehensive testing.

### Consultative Interaction Technique

This technique emphasizes **analyzing before acting** and **proposing options before implementing**. Instead of immediately making changes, the assistant:

1. **Analyzes** the current state and identifies specific issues
2. **Categorizes** problems by impact (CRITICAL, MAINTAINABILITY, etc.)
3. **Proposes** multiple solution options with clear trade-offs
4. **Asks** the user to choose their preferred approach
5. **Implements** based on user selection

**Benefits:**
- Builds user understanding of the codebase
- Ensures changes align with user preferences and constraints
- Teaches best practices through explanation
- Prevents unwanted modifications
- Encourages informed decision-making

**Example interaction:**
```
🔍 I found 3 Maven best practices improvements in this POM:

1. **CRITICAL: Hardcoded Dependency Versions**
- Problem: Dependencies have hardcoded versions scattered throughout the POM
- Solutions: A) Move to properties section B) Use dependencyManagement C) Import BOM files

2. **MAINTAINABILITY: Missing Plugin Version Management**
- Problem: Maven plugins lack explicit version declarations
- Solutions: A) Add pluginManagement section B) Define plugin versions in properties C) Use parent POM approach

3. **ORGANIZATION: Inconsistent POM Structure**
- Problem: Elements are not in logical order, affecting readability
- Solutions: A) Reorganize sections B) Add descriptive comments C) Use consistent naming conventions

Which would you like to implement? (1A, 1B, 1C, 2A, 2B, 2C, 3A, 3B, 3C, or 'show more details')
```

Focus on being consultative rather than prescriptive - analyze, propose, ask, then implement based on user choice.

### Implementing These Principles

These guidelines are built upon the following core principles:

1. **Standardized Framework Selection**: Utilize a widely accepted logging facade (preferably SLF4J) and a robust underlying implementation (Logback or Log4j2). This promotes consistency, flexibility, and access to advanced logging features.
2. **Meaningful and Consistent Log Levels**: Employ logging levels (ERROR, WARN, INFO, DEBUG, TRACE) deliberately and consistently to categorize the severity and importance of messages. This allows for effective filtering, monitoring, and targeted issue diagnosis.
3. **Adherence to Core Logging Practices**: Follow fundamental best practices such as using parameterized logging (avoiding string concatenation for performance and clarity), always logging exceptions with their stack traces, never logging sensitive data directly (PII, credentials).
4. **Thoughtful and Flexible Configuration**: Manage logging configuration externally (e.g., `logback.xml`, `log4j2.xml`). Tailor configurations for different environments (dev, test, prod) with appropriate log levels for various packages, clear and informative output formats (including timestamps, levels, logger names, thread info), and robust log rotation and retention policies.
5. **Security-Conscious Logging**: Prioritize security in all logging activities. Actively mask or filter sensitive information, control access to log files and log management systems, use secure protocols for transmitting logs, and ensure compliance with relevant data protection regulations (e.g., GDPR, HIPAA).
6. **Proactive Log Monitoring and Alerting**: Implement centralized log aggregation systems (e.g., ELK Stack, Splunk, Grafana Loki). Establish automated alerts based on log patterns, error rates, or specific critical events to enable proactive issue detection and rapid response.
7. **Comprehensive Logging Validation Through Testing**: Integrate logging into the testing strategy. Assert that critical log messages (especially errors and warnings) are generated as expected under specific conditions, verify log formats, test log level filtering, and assess any performance impact of logging.

Remember, good logging in Java is about operational excellence - making your application's behavior transparent and debuggable while maintaining security and performance.

## Constraints

Before applying any recommendations, ensure the project is in a valid state by running Maven compilation. Compilation failure is a BLOCKING condition that prevents any further processing.

- **MANDATORY**: Run `./mvnw compile` or `mvn compile` before applying any change
- **PREREQUISITE**: Project must compile successfully and pass basic validation checks before any optimization
- **CRITICAL SAFETY**: If compilation fails, IMMEDIATELY STOP and DO NOT CONTINUE with any recommendations
- **BLOCKING CONDITION**: Compilation errors must be resolved by the user before proceeding with any object-oriented design improvements
- **NO EXCEPTIONS**: Under no circumstances should design recommendations be applied to a project that fails to compile

## Examples

### Table of contents

- Example 1: Choose an Appropriate Logging Framework
- Example 2: Understand and Use Logging Levels Correctly
- Example 3: Adhere to Core Logging Practices
- Example 4: Follow Configuration Best Practices
- Example 5: Implement Secure Logging Practices
- Example 6: Establish Effective Log Monitoring and Alerting
- Example 7: Incorporate Logging in Testing

### Example 1: Choose an Appropriate Logging Framework

Title: Select a Standard Logging Facade and Implementation
Description: Using a standard logging facade like SLF4J allows for flexibility in choosing and switching an underlying logging implementation. The primary recommendation is SLF4J with Logback for its robustness and feature-richness.

**Good example:**

```java
// GOOD: Using SLF4J facade with proper logger declaration
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Objects;

public class UserService {
    // Logger declared using SLF4J - static final per class
    private static final Logger logger = LoggerFactory.getLogger(UserService.class);

    public void performAction(String input) {
        // SLF4J parameterized logging - efficient and readable
        logger.info("Performing action with input: {}", input);

        if (Objects.isNull(input) || input.isEmpty()) {
            logger.warn("Input is null or empty, using default behavior");
            input = "default";
        }

        try {
            processInput(input);
            logger.debug("Action completed successfully for input: {}", input);
        } catch (ProcessingException e) {
            logger.error("Failed to process input: {}", input, e);
            throw e;
        }
    }

    public void performComplexOperation(String userId, String operation) {
        // Using MDC (Mapped Diagnostic Context) for contextual logging
        try (var mdcCloseable = org.slf4j.MDC.putCloseable("userId", userId)) {
            logger.info("Starting operation: {}", operation);

            // All log statements in this block will include userId context
            performInternalSteps(operation);

            logger.info("Operation completed successfully");
        } catch (Exception e) {
            logger.error("Operation failed", e);
            throw e;
        }
    }

    private void processInput(String input) throws ProcessingException {
        // Simulate processing that might fail
        if ("error".equals(input)) {
            throw new ProcessingException("Invalid input: " + input);
        }
        logger.trace("Processing step completed for: {}", input);
    }

    private void performInternalSteps(String operation) {
        logger.debug("Executing internal step 1 for operation: {}", operation);
        // ... business logic
        logger.debug("Executing internal step 2 for operation: {}", operation);
        // ... more business logic
    }

    private static class ProcessingException extends Exception {
        public ProcessingException(String message) {
            super(message);
        }
    }
}
```

**Bad example:**

```java
// AVOID: Using System.out.println or direct logging implementation
public class BadLoggingService {

    public void performAction(String input) {
        // BAD: Using System.out.println - no control, no levels, no formatting
        System.out.println("Starting action with: " + input);

        if (input == null || input.isEmpty()) {
            // BAD: Using System.err - not integrated with logging framework
            System.err.println("Warning: Input is null or empty!");
        }

        try {
            processInput(input);
            System.out.println("Action completed for: " + input);
        } catch (Exception e) {
            // BAD: Just printing stack trace to stderr
            e.printStackTrace();
            // No structured logging, no log levels, no context
        }
    }

    // BAD: Directly using concrete logging implementation
    private java.util.logging.Logger julLogger =
        java.util.logging.Logger.getLogger(BadLoggingService.class.getName());

    public void anotherMethod() {
        // BAD: Tied to specific implementation, less flexible
        julLogger.info("Using JUL directly");
    }

    // BAD: Multiple logging frameworks in same class
    private org.apache.logging.log4j.Logger log4jLogger =
        org.apache.logging.log4j.LogManager.getLogger(BadLoggingService.class);

    public void confusedLogging() {
        julLogger.info("Using JUL");
        log4jLogger.info("Using Log4j");
        System.out.println("Using System.out");
        // Inconsistent and confusing!
    }
}
```

### Example 2: Understand and Use Logging Levels Correctly

Title: Apply Appropriate Logging Levels for Messages
Description: Use logging levels consistently to categorize the severity and importance of log messages. ERROR for critical issues, WARN for potentially harmful situations, INFO for important business events, DEBUG for detailed information, and TRACE for fine-grained debugging.

**Good example:**

```java
// GOOD: Proper usage of logging levels
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Objects;

public class OrderProcessor {
    private static final Logger logger = LoggerFactory.getLogger(OrderProcessor.class);

    public void processOrder(String orderId, String customerId) {
        logger.trace("Entering processOrder with orderId: {}, customerId: {}", orderId, customerId);

        // INFO: Important business events
        logger.info("Processing order {} for customer {}", orderId, customerId);

        try {
            // Validate inputs
            if (Objects.isNull(orderId) || orderId.trim().isEmpty()) {
                // WARN: Potentially harmful situation that can be recovered
                logger.warn("Order ID is null or empty for customer {}. Using generated ID.", customerId);
                orderId = generateOrderId();
            }

            // DEBUG: Detailed information for development/troubleshooting
            logger.debug("Validating order {} inventory", orderId);
            validateInventory(orderId);

            logger.debug("Calculating pricing for order {}", orderId);
            calculatePricing(orderId);

            logger.debug("Processing payment for order {}", orderId);
            processPayment(orderId);

            // INFO: Successful completion of important business operation
            logger.info("Order {} processed successfully for customer {}", orderId, customerId);

        } catch (InventoryException e) {
            // WARN: Expected business exception that can be handled
            logger.warn("Insufficient inventory for order {}. Will backorder.", orderId, e);
            handleBackorder(orderId);

        } catch (PaymentException e) {
            // ERROR: Critical failure requiring immediate attention
            logger.error("Payment processing failed for order {}. Customer: {}",
                        orderId, customerId, e);
            throw new OrderProcessingException("Payment failed", e);

        } catch (Exception e) {
            // ERROR: Unexpected critical error
            logger.error("Unexpected error processing order {} for customer {}",
                        orderId, customerId, e);
            throw new OrderProcessingException("Unexpected error", e);
        }

        logger.trace("Exiting processOrder for orderId: {}", orderId);
    }

    public void performHealthCheck() {
        logger.debug("Starting health check");

        try {
            checkDatabaseConnection();
            checkExternalServices();

            // INFO: System status information
            logger.info("Health check passed - all systems operational");

        } catch (HealthCheckException e) {
            // ERROR: System health issue requiring immediate attention
            logger.error("Health check failed - system may be degraded", e);
        }
    }

    // Example methods
    private String generateOrderId() { return "ORD-" + System.currentTimeMillis(); }
    private void validateInventory(String orderId) throws InventoryException { /* ... */ }
    private void calculatePricing(String orderId) { /* ... */ }
    private void processPayment(String orderId) throws PaymentException { /* ... */ }
    private void handleBackorder(String orderId) { /* ... */ }
    private void checkDatabaseConnection() throws HealthCheckException { /* ... */ }
    private void checkExternalServices() throws HealthCheckException { /* ... */ }

    // Exception classes
    private static class InventoryException extends Exception {
        public InventoryException(String message) { super(message); }
    }
    private static class PaymentException extends Exception {
        public PaymentException(String message) { super(message); }
    }
    private static class OrderProcessingException extends RuntimeException {
        public OrderProcessingException(String message, Throwable cause) { super(message, cause); }
    }
    private static class HealthCheckException extends Exception {
        public HealthCheckException(String message) { super(message); }
    }
}
```

**Bad example:**

```java
// AVOID: Misusing logging levels
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class BadLevelUsage {
    private static final Logger logger = LoggerFactory.getLogger(BadLevelUsage.class);

    public void processUser(String userId) {
        // BAD: Using INFO for debug-level details
        logger.info("Method entry: processUser with parameter: " + userId);
        logger.info("Creating new StringBuilder object");
        logger.info("Checking if userId is null");

        if (userId == null) {
            // BAD: Using ERROR for a normal business condition
            logger.error("User ID is null!"); // This might be expected/handled
            return;
        }

        // BAD: Using WARN for normal flow information
        logger.warn("User ID is not null, proceeding with processing");

        try {
            String result = processUserData(userId);

            // BAD: Using ERROR for successful operations
            logger.error("Successfully processed user: " + userId + " with result: " + result);

        } catch (Exception e) {
            // BAD: Using INFO for critical errors
            logger.info("An error occurred: " + e.getMessage());
            // Should be ERROR or WARN depending on severity
        }

        // BAD: Overuse of TRACE for everything
        logger.trace("About to return from method");
        logger.trace("Setting return value to void");
        logger.trace("Method execution completed");
        // Too much noise - not useful
    }

    public void anotherBadExample(String data) {
        // BAD: String concatenation instead of parameterized logging
        logger.info("Processing data: " + data + " at time: " + System.currentTimeMillis());

        // BAD: Using DEBUG for important business events
        logger.debug("Payment of $1000 processed for customer ABC123");
        // This should be INFO - it's an important business event

        // BAD: Using same level for different severity issues
        logger.warn("Configuration file not found, using defaults");  // This is OK for WARN
        logger.warn("Database connection lost");  // This should be ERROR
        logger.warn("User entered invalid email format");  // This might be INFO or DEBUG
    }

    private String processUserData(String userId) {
        return "processed-" + userId;
    }
}
```

### Example 3: Adhere to Core Logging Practices

Title: Implement Fundamental Best Practices
Description: Follow core practices including using parameterized logging, proper exception handling, avoiding sensitive data exposure, and implementing performance considerations for logging operations.

**Good example:**

```java
// GOOD: Core logging best practices
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import java.util.Objects;

public class SecureTransactionService {
    private static final Logger logger = LoggerFactory.getLogger(SecureTransactionService.class);

    public void processPayment(String userId, String amount, String cardNumber) {
        // Set correlation ID for request tracing
        String correlationId = generateCorrelationId();
        MDC.put("correlationId", correlationId);

        try {
            logger.info("Processing payment for user: {}, amount: {}", userId, amount);

            // GOOD: Mask sensitive information before logging
            String maskedCard = maskCreditCard(cardNumber);
            logger.debug("Processing payment with card: {}", maskedCard);

            validatePaymentRequest(userId, amount, cardNumber);

            if (logger.isDebugEnabled()) {
                // GOOD: Guard clause for expensive operations
                String debugInfo = buildComplexDebugInfo(userId, amount);
                logger.debug("Payment validation details: {}", debugInfo);
            }

            processPaymentInternal(userId, amount, cardNumber);

            logger.info("Payment processed successfully for user: {}, correlation: {}",
                       userId, correlationId);

        } catch (ValidationException e) {
            // GOOD: Log exception with context but don't expose sensitive data
            logger.warn("Payment validation failed for user: {}, reason: {}, correlation: {}",
                       userId, e.getValidationError(), correlationId, e);
            throw e;

        } catch (PaymentProcessingException e) {
            // GOOD: Log critical error with full context
            logger.error("Payment processing failed for user: {}, amount: {}, correlation: {}",
                        userId, amount, correlationId, e);
            throw e;

        } catch (Exception e) {
            // GOOD: Catch unexpected exceptions and log with context
            logger.error("Unexpected error during payment processing for user: {}, correlation: {}",
                        userId, correlationId, e);
            throw new PaymentProcessingException("Unexpected error", e);

        } finally {
            // GOOD: Clean up MDC to prevent memory leaks
            MDC.remove("correlationId");
        }
    }

    public void processLargeDataSet(List<String> dataItems) {
        logger.info("Processing {} data items", dataItems.size());

        for (int i = 0; i < dataItems.size(); i++) {
            String item = dataItems.get(i);

            try {
                processDataItem(item);

                // GOOD: Log progress periodically, not for every item
                if (i % 1000 == 0) {
                    logger.debug("Processed {} of {} items", i, dataItems.size());
                }

            } catch (Exception e) {
                // GOOD: Log error but continue processing
                logger.warn("Failed to process item at index {}: {}", i, item, e);
            }
        }

        logger.info("Completed processing {} data items", dataItems.size());
    }

    // Utility methods
    private String maskCreditCard(String cardNumber) {
        if (cardNumber == null || cardNumber.length() < 8) {
            return "****";
        }
        return cardNumber.substring(0, 4) + "****" + cardNumber.substring(cardNumber.length() - 4);
    }

    private String generateCorrelationId() {
        return "TXN-" + System.currentTimeMillis() + "-" + Thread.currentThread().getId();
    }

    private String buildComplexDebugInfo(String userId, String amount) {
        // Simulate expensive debug information building
        return String.format("User: %s, Amount: %s, Timestamp: %d",
                           userId, amount, System.currentTimeMillis());
    }

    private void validatePaymentRequest(String userId, String amount, String cardNumber)
            throws ValidationException {
        if (Objects.isNull(userId) || userId.trim().isEmpty()) {
            throw new ValidationException("INVALID_USER_ID");
        }
        // More validation...
    }

    private void processPaymentInternal(String userId, String amount, String cardNumber)
            throws PaymentProcessingException {
        // Simulate payment processing
        if ("fail".equals(userId)) {
            throw new PaymentProcessingException("Payment gateway error");
        }
    }

    private void processDataItem(String item) {
        // Simulate data processing
        if ("error".equals(item)) {
            throw new RuntimeException("Processing failed for item: " + item);
        }
    }

    // Exception classes
    private static class ValidationException extends Exception {
        private final String validationError;

        public ValidationException(String validationError) {
            super("Validation failed: " + validationError);
            this.validationError = validationError;
        }

        public String getValidationError() {
            return validationError;
        }
    }

    private static class PaymentProcessingException extends RuntimeException {
        public PaymentProcessingException(String message) {
            super(message);
        }

        public PaymentProcessingException(String message, Throwable cause) {
            super(message, cause);
        }
    }
}
```

**Bad example:**

```java
// AVOID: Poor logging practices
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class PoorLoggingPractices {
    private static final Logger logger = LoggerFactory.getLogger(PoorLoggingPractices.class);

    public void processPayment(String userId, String amount, String cardNumber, String ssn) {
        // BAD: String concatenation instead of parameterized logging
        logger.info("Processing payment for user: " + userId + " amount: " + amount);

        // BAD: Logging sensitive information directly
        logger.debug("Credit card: " + cardNumber + ", SSN: " + ssn);

        try {
            validatePayment(userId, amount);

            // BAD: Expensive operation without guard clause
            logger.debug("Payment details: " + buildExpensiveDebugString(userId, amount, cardNumber));

            processPaymentTransaction(userId, amount, cardNumber);

        } catch (Exception e) {
            // BAD: Swallowing exception without proper logging
            logger.info("Payment failed: " + e.getMessage());
            // Lost the stack trace and context!

            // BAD: Logging sensitive data in error message
            logger.error("Payment failed for card: " + cardNumber + " and SSN: " + ssn);
        }
    }

    public void processLargeDataSet(List<String> items) {
        // BAD: Logging every single item in large dataset
        for (String item : items) {
            logger.debug("Processing item: " + item); // Will flood logs
            processItem(item);
            logger.debug("Completed item: " + item); // Even more noise
        }
    }

    public void handleUserLogin(String username, String password) {
        // BAD: Logging passwords - NEVER do this!
        logger.debug("User login attempt: username=" + username + ", password=" + password);

        try {
            authenticateUser(username, password);
            // BAD: Inconsistent logging format
            logger.info("User " + username + " logged in successfully");
        } catch (AuthenticationException e) {
            // BAD: Using wrong log level and exposing sensitive info
            logger.error("Login failed for " + username + " with password " + password);
        }
    }

    public void performDatabaseOperation(String query, String connectionString) {
        // BAD: Logging database connection strings (may contain credentials)
        logger.debug("Executing query: " + query + " on connection: " + connectionString);

        try {
            executeQuery(query);
        } catch (SQLException e) {
            // BAD: Not using parameterized logging with exception
            logger.error("SQL error: " + e.getMessage() + " for query: " + query);
            // Stack trace is lost!
        }
    }

    // BAD: No try-with-resources or proper cleanup for MDC
    public void badMDCUsage(String userId) {
        org.slf4j.MDC.put("userId", userId);
        logger.info("Processing for user");

        // ... some processing ...

        // BAD: Forgot to clear MDC - memory leak!
        // MDC.clear() or MDC.remove("userId") is missing
    }

    // Helper methods with poor exception handling
    private String buildExpensiveDebugString(String userId, String amount, String cardNumber) {
        // Simulate expensive operation
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10000; i++) {
            sb.append("Debug info for ").append(userId).append(" ");
        }
        return sb.toString();
    }

    private void validatePayment(String userId, String amount) throws ValidationException {
        if (userId == null) throw new ValidationException("Invalid user");
    }

    private void processPaymentTransaction(String userId, String amount, String cardNumber) {
        // Simulate processing
    }

    private void processItem(String item) {
        // Simulate processing
    }

    private void authenticateUser(String username, String password) throws AuthenticationException {
        if ("baduser".equals(username)) {
            throw new AuthenticationException("Invalid credentials");
        }
    }

    private void executeQuery(String query) throws SQLException {
        if (query.contains("DROP")) {
            throw new SQLException("Invalid query");
        }
    }

    // Exception classes
    private static class ValidationException extends Exception {
        public ValidationException(String message) { super(message); }
    }
    private static class AuthenticationException extends Exception {
        public AuthenticationException(String message) { super(message); }
    }
    private static class SQLException extends Exception {
        public SQLException(String message) { super(message); }
    }
}
```

### Example 4: Follow Configuration Best Practices

Title: Configure Your Logging Framework Thoughtfully
Description: Proper configuration is key to effective logging. Use separate configurations per environment, implement different log levels for different packages, and include comprehensive output formats with timestamps, levels, logger names, and thread information.

**Good example:**

```java
// Configuration shown through usage - actual config would be in logback.xml or log4j2.xml
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;

public class ConfiguredLoggerExample {
    private static final Logger appLogger = LoggerFactory.getLogger(ConfiguredLoggerExample.class);
    private static final Logger performanceLogger = LoggerFactory.getLogger("performance." + ConfiguredLoggerExample.class.getName());

    public void performBusinessOperation(String operationId, String userId) {
        // Using MDC for contextual information
        MDC.put("operationId", operationId);
        MDC.put("userId", userId);

        try {
            long startTime = System.currentTimeMillis();
            appLogger.info("Starting business operation");

            // Simulate work
            Thread.sleep(100);

            long duration = System.currentTimeMillis() - startTime;
            performanceLogger.info("Operation completed in {} ms", duration);

            appLogger.info("Business operation completed successfully");

        } catch (InterruptedException e) {
            appLogger.warn("Operation interrupted", e);
            Thread.currentThread().interrupt();
        } catch (Exception e) {
            appLogger.error("Business operation failed", e);
            throw new RuntimeException("Operation failed", e);
        } finally {
            // Always clear MDC
            MDC.clear();
        }
    }

    public void demonstrateLogLevels() {
        // These will be filtered based on configuration
        appLogger.trace("This is trace level - very detailed");
        appLogger.debug("This is debug level - detailed for development");
        appLogger.info("This is info level - important business events");
        appLogger.warn("This is warn level - potentially harmful situations");
        appLogger.error("This is error level - critical issues");
    }

    public static void main(String[] args) {
        ConfiguredLoggerExample example = new ConfiguredLoggerExample();
        example.performBusinessOperation("OP123", "user456");
        example.demonstrateLogLevels();
    }
}
```

**Bad example:**

```java
// Poor configuration consequences
public class BadConfigConsequences {
    private static final Logger logger = LoggerFactory.getLogger(BadConfigConsequences.class);

    public void performOperation() {
        // If configuration is bad (everything at TRACE), this floods logs
        logger.trace("Entering method");
        logger.trace("Creating variables");
        logger.trace("About to check condition");

        logger.info("User logged in.");
        logger.error("Failed to connect to DB.", new RuntimeException("DB connection timeout"));

        // With bad pattern configuration, output might be:
        // User logged in.
        // Failed to connect to DB.
        // Problem: No timestamp, no level, no logger name, no thread info
    }

    public static void main(String[] args) {
        BadConfigConsequences example = new BadConfigConsequences();
        example.performOperation();
    }
}
```

### Example 5: Implement Secure Logging Practices

Title: Ensure Logs Do Not Compromise Security
Description: Actively mask or filter sensitive data, control access to log files, use secure transmission protocols, and comply with data protection regulations when logging information.

**Good example:**

```java
// GOOD: Secure logging practices
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.regex.Pattern;
import java.util.Objects;

public class SecureLoggingService {
    private static final Logger logger = LoggerFactory.getLogger(SecureLoggingService.class);

    // Patterns for detecting sensitive data
    private static final Pattern CREDIT_CARD_PATTERN = Pattern.compile("\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}[\\s-]?\\d{4}");
    private static final Pattern SSN_PATTERN = Pattern.compile("\\d{3}-\\d{2}-\\d{4}");
    private static final Pattern EMAIL_PATTERN = Pattern.compile("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}");

    public void processUserRegistration(String username, String email, String ssn, String creditCard) {
        // GOOD: Sanitize all user inputs before logging
        String sanitizedUsername = sanitizeForLogging(username);
        String maskedEmail = maskEmail(email);
        String hashedSSN = hashSensitiveData(ssn);
        String maskedCard = maskCreditCard(creditCard);

        logger.info("Processing registration for user: {}, email: {}", sanitizedUsername, maskedEmail);
        logger.debug("User data validation - SSN hash: {}, card mask: {}", hashedSSN, maskedCard);

        try {
            validateUserData(username, email, ssn, creditCard);
            createUserAccount(username, email);

            // GOOD: Log successful operation without sensitive data
            logger.info("User registration completed successfully for: {}", sanitizedUsername);

            // GOOD: Security event logging for audit trail
            logger.info("SECURITY_EVENT: New user registration - username: {}, timestamp: {}",
                       sanitizedUsername, System.currentTimeMillis());

        } catch (ValidationException e) {
            // GOOD: Log validation failure without exposing sensitive validation details
            logger.warn("User registration failed validation for user: {}, error code: {}",
                       sanitizedUsername, e.getErrorCode());

        } catch (SecurityException e) {
            // GOOD: Security incidents logged with careful information control
            logger.error("SECURITY_ALERT: Registration security violation for user: {}, violation type: {}",
                        sanitizeForLogging(username), e.getViolationType());
            // Don't log the actual violation details that might help attackers

        } catch (Exception e) {
            // GOOD: Generic error logging without sensitive context
            logger.error("User registration failed for user: {} due to system error",
                        sanitizedUsername, e);
        }
    }

    public void processPayment(String userId, PaymentRequest request) {
        String correlationId = generateSecureCorrelationId();

        try {
            // GOOD: Log business operation with masked sensitive data
            logger.info("Processing payment - user: {}, amount: {}, correlation: {}",
                       userId, request.getAmount(), correlationId);

            // GOOD: Validate and log without exposing card details
            validatePaymentMethod(request.getPaymentMethod());
            logger.debug("Payment method validated for correlation: {}", correlationId);

            ChargeResult result = processCharge(request);

            // GOOD: Log success with minimal necessary information
            logger.info("Payment processed successfully - correlation: {}, transaction: {}",
                       correlationId, result.getTransactionId());

            // GOOD: Business intelligence logging (aggregated, non-sensitive)
            logger.info("METRICS: Payment processed - amount: {}, merchant: {}, timestamp: {}",
                       request.getAmount(), request.getMerchantId(), System.currentTimeMillis());

        } catch (FraudDetectedException e) {
            // GOOD: Security event with controlled information
            logger.error("SECURITY_ALERT: Fraud detected - correlation: {}, risk_score: {}, user: {}",
                        correlationId, e.getRiskScore(), userId);
            // Don't log fraud detection details that could help bypass detection

        } catch (PaymentException e) {
            // GOOD: Business error with safe context
            logger.error("Payment failed - correlation: {}, error_type: {}",
                        correlationId, e.getErrorType(), e);
        }
    }

    // Secure data masking utilities
    private String sanitizeForLogging(String input) {
        if (input == null) return "[null]";

        // Remove potentially dangerous characters for log injection protection
        String sanitized = input.replaceAll("[\r\n\t]", "_")
                               .replaceAll("[<>\"'&]", "*");

        // Limit length to prevent log flooding
        if (sanitized.length() > 100) {
            sanitized = sanitized.substring(0, 97) + "...";
        }

        return sanitized;
    }

    private String maskEmail(String email) {
        if (email == null || !EMAIL_PATTERN.matcher(email).matches()) {
            return "[INVALID_EMAIL]";
        }

        int atIndex = email.indexOf('@');
        if (atIndex < 2) {
            return "**@" + email.substring(atIndex + 1);
        }

        return email.substring(0, 2) + "***@" + email.substring(atIndex + 1);
    }

    private String maskCreditCard(String cardNumber) {
        if (cardNumber == null || cardNumber.length() < 8) {
            return "[INVALID_CARD]";
        }

        String digitsOnly = cardNumber.replaceAll("[^\\d]", "");
        if (digitsOnly.length() < 8) {
            return "[INVALID_CARD]";
        }

        return digitsOnly.substring(0, 4) + "****" +
               digitsOnly.substring(digitsOnly.length() - 4);
    }

    private String hashSensitiveData(String data) {
        if (data == null) return "[null]";

        // Use a secure hash for audit purposes (not for security)
        return "HASH_" + Math.abs(data.hashCode());
    }

    private String generateSecureCorrelationId() {
        return "CORR_" + System.currentTimeMillis() + "_" +
               Thread.currentThread().getId();
    }

    // Mock classes and methods
    private void validateUserData(String username, String email, String ssn, String creditCard)
            throws ValidationException {
        if (username == null || username.trim().isEmpty()) {
            throw new ValidationException("INVALID_USERNAME");
        }
    }

    private void createUserAccount(String username, String email) {
        // Account creation logic
    }

    private void validatePaymentMethod(String paymentMethod) {
        // Payment validation logic
    }

    private ChargeResult processCharge(PaymentRequest request) throws PaymentException {
        // Payment processing logic
        return new ChargeResult("TXN_" + System.currentTimeMillis());
    }

    // Mock classes
    private static class PaymentRequest {
        private String amount = "100.00";
        private String paymentMethod = "card";
        private String merchantId = "MERCHANT_123";

        public String getAmount() { return amount; }
        public String getPaymentMethod() { return paymentMethod; }
        public String getMerchantId() { return merchantId; }
    }

    private static class ChargeResult {
        private final String transactionId;
        public ChargeResult(String transactionId) { this.transactionId = transactionId; }
        public String getTransactionId() { return transactionId; }
    }

    private static class ValidationException extends Exception {
        private final String errorCode;
        public ValidationException(String errorCode) {
            super("Validation failed: " + errorCode);
            this.errorCode = errorCode;
        }
        public String getErrorCode() { return errorCode; }
    }

    private static class SecurityException extends Exception {
        private final String violationType;
        public SecurityException(String violationType) {
            super("Security violation: " + violationType);
            this.violationType = violationType;
        }
        public String getViolationType() { return violationType; }
    }

    private static class FraudDetectedException extends Exception {
        private final int riskScore;
        public FraudDetectedException(int riskScore) {
            super("Fraud detected with risk score: " + riskScore);
            this.riskScore = riskScore;
        }
        public int getRiskScore() { return riskScore; }
    }

    private static class PaymentException extends Exception {
        private final String errorType;
        public PaymentException(String errorType) {
            super("Payment error: " + errorType);
            this.errorType = errorType;
        }
        public String getErrorType() { return errorType; }
    }
}
```

**Bad example:**

```java
// AVOID: Insecure logging practices
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class InsecureLoggingService {
    private static final Logger logger = LoggerFactory.getLogger(InsecureLoggingService.class);

    public void processUserRegistration(String username, String password, String email,
                                      String ssn, String creditCard) {
        // BAD: Logging passwords - NEVER do this!
        logger.debug("User registration: username={}, password={}, email={}",
                    username, password, email);

        // BAD: Logging full SSN and credit card numbers
        logger.info("Processing registration for SSN: {} with credit card: {}", ssn, creditCard);

        try {
            validateUser(username, password, email, ssn, creditCard);
            createAccount(username, password);

        } catch (ValidationException e) {
            // BAD: Exposing sensitive validation details
            logger.error("Validation failed for user {} with password {} - details: {}",
                        username, password, e.getValidationDetails());

        } catch (SecurityException e) {
            // BAD: Logging detailed security information that could help attackers
            logger.error("Security violation for user {}: attack vector: {}, payload: {}, " +
                        "system_path: {}, internal_error: {}",
                        username, e.getAttackVector(), e.getPayload(),
                        e.getSystemPath(), e.getInternalError());
        }
    }

    public void processPayment(String userId, String cardNumber, String cvv, String amount) {
        // BAD: Logging complete payment card information
        logger.info("Processing payment: user={}, card={}, cvv={}, amount={}",
                   userId, cardNumber, cvv, amount);

        try {
            validateCard(cardNumber, cvv);

            // BAD: Logging sensitive database connection info
            logger.debug("Connecting to payment DB with connection string: {}",
                        getDatabaseConnectionString());

            processTransaction(cardNumber, cvv, amount);

        } catch (FraudException e) {
            // BAD: Exposing fraud detection algorithms and thresholds
            logger.error("Fraud detected for card {}: algorithm={}, threshold={}, " +
                        "risk_factors={}, detection_rules={}",
                        cardNumber, e.getAlgorithm(), e.getThreshold(),
                        e.getRiskFactors(), e.getDetectionRules());

        } catch (PaymentException e) {
            // BAD: Including full stack trace with sensitive system information
            logger.error("Payment failed for card {} with full system details", cardNumber, e);
        }
    }

    public void handleSystemError(String operation, Exception e) {
        // BAD: Logging system internals that could help attackers
        logger.error("System error in operation {}: java_version={}, system_properties={}, " +
                    "environment_variables={}, file_paths={}",
                    operation, System.getProperty("java.version"),
                    System.getProperties(), System.getenv(),
                    System.getProperty("user.dir"));

        // BAD: Full stack trace might expose sensitive system information
        e.printStackTrace(); // Goes to stderr, not controlled by logging config
    }

    public void logUserActivity(String userId, String sessionId, String ipAddress,
                               String userAgent, String requestData) {
        // BAD: Logging PII and potentially sensitive request data
        logger.info("User activity: user={}, session={}, ip={}, userAgent={}, request={}",
                   userId, sessionId, ipAddress, userAgent, requestData);

        // BAD: No data retention consideration
        // This could violate GDPR, CCPA, or other privacy regulations
    }

    public void authenticateUser(String username, String password, String loginToken) {
        // BAD: Logging authentication credentials
        logger.debug("Authentication attempt: username={}, password={}, token={}",
                    username, password, loginToken);

        try {
            boolean success = authenticate(username, password, loginToken);
            if (!success) {
                // BAD: Detailed failure information that could help brute force attacks
                logger.warn("Login failed for {} - password_attempts={}, last_success={}, " +
                           "account_locked={}, failed_reasons={}",
                           username, getPasswordAttempts(username),
                           getLastSuccessfulLogin(username), isAccountLocked(username),
                           getFailureReasons(username));
            }
        } catch (Exception e) {
            // BAD: Logging authentication errors with sensitive context
            logger.error("Authentication system error for user {} with credentials: " +
                        "password={}, token={}", username, password, loginToken, e);
        }
    }

    // Mock methods with security issues
    private String getDatabaseConnectionString() {
        return "jdbc:mysql://prod-db:3306/payments?user=admin&password=secret123";
    }

    private void validateUser(String username, String password, String email, String ssn, String creditCard)
            throws ValidationException { /* ... */ }
    private void createAccount(String username, String password) { /* ... */ }
    private void validateCard(String cardNumber, String cvv) { /* ... */ }
    private void processTransaction(String cardNumber, String cvv, String amount)
            throws PaymentException { /* ... */ }
    private boolean authenticate(String username, String password, String token) { return true; }
    private int getPasswordAttempts(String username) { return 3; }
    private long getLastSuccessfulLogin(String username) { return System.currentTimeMillis(); }
    private boolean isAccountLocked(String username) { return false; }
    private String getFailureReasons(String username) { return "invalid_password"; }

    // Exception classes with sensitive information exposure
    private static class ValidationException extends Exception {
        private final String validationDetails;
        public ValidationException(String details) {
            this.validationDetails = details;
        }
        public String getValidationDetails() { return validationDetails; }
    }

    private static class SecurityException extends Exception {
        private final String attackVector, payload, systemPath, internalError;
        public SecurityException(String attackVector, String payload, String systemPath, String internalError) {
            this.attackVector = attackVector;
            this.payload = payload;
            this.systemPath = systemPath;
            this.internalError = internalError;
        }
        public String getAttackVector() { return attackVector; }
        public String getPayload() { return payload; }
        public String getSystemPath() { return systemPath; }
        public String getInternalError() { return internalError; }
    }

    private static class FraudException extends Exception {
        private final String algorithm, threshold, riskFactors, detectionRules;
        public FraudException(String algorithm, String threshold, String riskFactors, String detectionRules) {
            this.algorithm = algorithm;
            this.threshold = threshold;
            this.riskFactors = riskFactors;
            this.detectionRules = detectionRules;
        }
        public String getAlgorithm() { return algorithm; }
        public String getThreshold() { return threshold; }
        public String getRiskFactors() { return riskFactors; }
        public String getDetectionRules() { return detectionRules; }
    }

    private static class PaymentException extends Exception {
        public PaymentException(String message) { super(message); }
    }
}
```

### Example 6: Establish Effective Log Monitoring and Alerting

Title: Implement Log Aggregation, Monitoring, and Alerting
Description: Set up centralized log aggregation, implement alerts based on log patterns, use structured logging for querying, and regularly analyze logs to identify trends and issues.

**Good example:**

```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import java.util.Objects;
import java.util.UUID;

public class MonitoredService {
    private static final Logger logger = LoggerFactory.getLogger(MonitoredService.class);

    public void handleApiRequest(String endpoint, String payload) {
        String requestId = UUID.randomUUID().toString();
        MDC.put("requestId", requestId);
        MDC.put("endpoint", endpoint);

        try {
            logger.info("API request received");

            if (payload.contains("<script>")) {
                // Log a security-sensitive event that monitoring tools can pick up for alerts.
                logger.warn("SECURITY_ALERT: Potential XSS attempt detected in payload for endpoint: {}", endpoint);
                // Handle error, e.g., return 400 Bad Request
                return;
            }

            // Simulate some processing
            if (endpoint.equals("/critical_op")) {
                if (Math.random() > 0.9) { // Simulate a sporadic critical failure
                    throw new RuntimeException("Critical operation failure detected!");
                }
            }

            logger.info("API request processed successfully");

            // Structured logging for metrics and monitoring
            logger.info("METRICS: endpoint={}, duration={}, status=success", endpoint, System.currentTimeMillis() % 1000);

        } catch (RuntimeException e) {
            // This ERROR log (especially with stack trace) would be a key candidate for alerting.
            logger.error("ALERT: Unhandled exception during API request processing", e);
            // Could trigger immediate alert in monitoring system
        } finally {
            MDC.clear();
        }
    }

    public void performHealthCheck() {
        try {
            // Simulate health checks
            checkDatabase();
            checkExternalService();

            logger.info("HEALTH_CHECK: All systems operational");

        } catch (Exception e) {
            logger.error("HEALTH_CHECK: System health check failed", e);
            // This would trigger alerts for operational teams
        }
    }

    private void checkDatabase() {
        // Simulate database check
        if (Math.random() > 0.95) {
            throw new RuntimeException("Database connection failed");
        }
    }

    private void checkExternalService() {
        // Simulate external service check
        if (Math.random() > 0.98) {
            throw new RuntimeException("External service unavailable");
        }
    }

    public static void main(String[] args) {
        MonitoredService service = new MonitoredService();

        // These logs would be searchable in monitoring systems by:
        // - requestId for request tracing
        // - endpoint for API-specific analysis
        // - SECURITY_ALERT for security incident detection
        // - HEALTH_CHECK for system monitoring
        // - METRICS for performance analysis

        service.handleApiRequest("/user_data", "{\"data\": \"normal\"}");
        service.handleApiRequest("/submit_form", "payload with <script>alert('XSS')</script>");

        for (int i = 0; i < 20; i++) {
            service.handleApiRequest("/critical_op", "some_data");
        }

        service.performHealthCheck();
    }
}
```

**Bad example:**

```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Objects;

public class UnmonitoredService {
    private static final Logger logger = LoggerFactory.getLogger(UnmonitoredService.class);

    public void doWork() {
        try {
            logger.info("Work started.");
            // ... some logic ...
            if (Math.random() > 0.5) {
                throw new Exception("Something went wrong randomly!");
            }
            logger.info("Work finished.");
        } catch (Exception e) {
            // Logs an error, but if logs are only on local disk and not monitored,
            // this critical issue might go unnoticed for a long time.
            logger.error("Error during work", e);
        }
    }

    public static void main(String[] args) {
        UnmonitoredService service = new UnmonitoredService();
        for (int i = 0; i < 5; i++) {
            service.doWork();
        }
        // Problem: Logs are likely just going to console or a local file.
        // - No central aggregation: Difficult to search across instances or time.
        // - No alerts: Critical errors might be missed until users report them.
        // - No analysis: Trends or recurring non-fatal issues are hard to spot.
    }
}
```

### Example 7: Incorporate Logging in Testing

Title: Validate Logging Behavior and Impact During Testing
Description: Ensure logging works as expected and doesn't negatively impact the application. Assert that specific log messages are generated, verify log formats, test different logging levels, and check performance impact.

**Good example:**

```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Objects;

// ---- System Under Test ----
class ImportantService {
    private static final Logger logger = LoggerFactory.getLogger(ImportantService.class);

    public void processImportantData(String dataId) {
        if (Objects.isNull(dataId)) {
            logger.error("Data ID is null, cannot process.");
            throw new IllegalArgumentException("Data ID cannot be null");
        }
        if (dataId.startsWith("invalid_")) {
            logger.warn("Received potentially invalid data ID: {}", dataId);
            // continue processing with caution
        }
        logger.info("Processing data for ID: {}", dataId);
        // ... actual processing ...
    }
}

// ---- Test Example (Conceptual - would use JUnit/TestNG) ----
public class LoggingTestExample {

    // This would be actual test code using testing frameworks
    public void demonstrateLoggingTests() {
        ImportantService service = new ImportantService();

        // Test 1: Verify ERROR log for null input
        try {
            service.processImportantData(null);
            // Should not reach here
        } catch (IllegalArgumentException e) {
            // In real test, would capture logs and assert:
            // - ERROR level log contains "Data ID is null"
            // - Only one ERROR log entry
            System.out.println("Test 1 passed: ERROR log generated for null input");
        }

        // Test 2: Verify WARN log for invalid input
        service.processImportantData("invalid_XYZ");
        // In real test, would assert:
        // - WARN level log contains "Received potentially invalid data ID: invalid_XYZ"
        // - INFO level log contains "Processing data for ID: invalid_XYZ"
        System.out.println("Test 2 passed: WARN and INFO logs generated for invalid input");

        // Test 3: Verify INFO log for valid input
        service.processImportantData("valid_123");
        // In real test, would assert:
        // - Only INFO level log contains "Processing data for ID: valid_123"
        // - No WARN or ERROR logs
        System.out.println("Test 3 passed: INFO log generated for valid input");
    }

    public void performanceTestExample() {
        ImportantService service = new ImportantService();

        // Performance test: measure logging overhead
        long startTime = System.currentTimeMillis();

        for (int i = 0; i < 1000; i++) {
            service.processImportantData("test_" + i);
        }

        long duration = System.currentTimeMillis() - startTime;
        System.out.println("Performance test: 1000 operations completed in " + duration + "ms");

        // In real test, would assert that logging overhead is within acceptable limits
        // e.g., assert duration < 1000; // Less than 1ms per operation including logging
    }

    public static void main(String[] args) {
        LoggingTestExample test = new LoggingTestExample();
        test.demonstrateLoggingTests();
        test.performanceTestExample();

        System.out.println("In real implementation, use JUnit/TestNG with LogCapture utilities");
        System.out.println("Example dependencies: ch.qos.logback.classic.Logger with ListAppender");
    }
}
```

**Bad example:**

```java
// Code that is hard to test for logging behavior
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Objects;

public class UntestableLogging {
    private static final Logger logger = LoggerFactory.getLogger(UntestableLogging.class);

    public void complexOperation(String input) {
        // ... many lines of code ...
        if (input.equals("problem")) {
            // Log message is deeply embedded, possibly conditional, hard to trigger specifically
            // and verify without significant effort or refactoring.
            logger.warn("A specific problem occurred with input: {}", input);
        }
        // ... more code ...
        // No clear separation of concerns, making it hard to isolate and test logging.
    }

    public void methodWithSideEffects(String data) {
        // Expensive logging operation always executed
        logger.debug("Processing data: {}", buildExpensiveLogMessage(data));

        // No way to test if logging is impacting performance
        // No way to verify log content without running expensive operations
    }

    private String buildExpensiveLogMessage(String data) {
        // Simulate expensive operation that shouldn't run in production
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 10000; i++) {
            sb.append("Debug info: ").append(data).append(" iteration: ").append(i);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        UntestableLogging ul = new UntestableLogging();
        ul.complexOperation("test");
        ul.complexOperation("problem");
        ul.methodWithSideEffects("example");

        // Problem: Without proper test utilities or testable design,
        // verifying that the WARN message is logged correctly (and only when expected)
        // is difficult. Developers might skip testing logging, leading to unverified log output.
    }
}
```

## Output Format

- **ANALYZE** the current logging implementation to identify specific issues and categorize them by impact (CRITICAL, SECURITY, PERFORMANCE, MAINTAINABILITY, etc.)
- **CATEGORIZE** logging problems found: Framework Selection (inconsistent/outdated), Log Level Usage (inappropriate levels), Security Issues (sensitive data exposure), Configuration Problems (environment-specific needs), and Performance Impact (inefficient logging patterns)
- **PROPOSE** multiple solution options for each identified issue with clear trade-offs: Framework migration strategies (SLF4J adoption paths), log level optimization approaches, security hardening techniques, configuration management options, and performance improvement methods
- **EXPLAIN** the benefits and considerations of each proposed solution: Framework selection criteria (SLF4J vs direct implementations), log level best practices (ERROR/WARN/INFO/DEBUG/TRACE usage), security implications (data masking strategies), configuration approaches (environment-specific vs centralized), and monitoring integration options
- **PRESENT** comprehensive logging strategy options: Centralized aggregation approaches (ELK Stack, Splunk, Grafana Loki), alerting configuration choices, testing validation strategies, and operational monitoring procedures
- **ASK** the user to choose their preferred approach for each category of logging improvements rather than implementing all changes automatically
- **VALIDATE** that any proposed logging changes will compile, maintain existing functionality, and not introduce security vulnerabilities before implementation

## Safeguards

- **BLOCKING SAFETY CHECK**: ALWAYS run `./mvnw compile` before ANY logging recommendations
- **CRITICAL VALIDATION**: Execute `./mvnw clean verify` to ensure all tests pass after logging changes
- **SECURITY VERIFICATION**: Validate that no sensitive data (passwords, PII, tokens) is logged directly
- **PERFORMANCE MONITORING**: Ensure logging configurations don't introduce significant performance overhead
- **CONFIGURATION VALIDATION**: Verify logging configuration files are syntactically correct and environment-appropriate
- **ROLLBACK READINESS**: Ensure all logging changes can be easily reverted without system disruption
- **INCREMENTAL SAFETY**: Apply logging improvements incrementally, validating after each modification
- **LOG LEVEL VERIFICATION**: Confirm log levels are appropriate for production environments (avoid DEBUG/TRACE in prod)
- **DEPENDENCY COMPATIBILITY**: Verify logging framework dependencies don't conflict with existing project dependencies
- **OPERATIONAL CONTINUITY**: Ensure logging changes don't break existing monitoring, alerting, or log aggregation systems