Debug Logging in Production Applications: A Practical Guide

Production applications require sophisticated logging strategies to effectively monitor, troubleshoot, and maintain system health. I’ve implemented these patterns across various enterprise systems, and they’ve consistently proven their worth in critical situations.

Structured Logging with JSON

JSON logging transforms traditional text logs into structured data that’s easily parsed and analyzed. This pattern is essential for modern log aggregation systems.

public class StructuredLogger {
    private static final ObjectMapper mapper = new ObjectMapper();
    private static final Logger logger = LoggerFactory.getLogger(StructuredLogger.class);

    public void logBusinessEvent(String event, Map<String, Object> data) {
        try {
            LogEvent logEvent = new LogEvent(
                event,
                data,
                LocalDateTime.now(),
                Thread.currentThread().getName()
            );
            logger.info(mapper.writeValueAsString(logEvent));
        } catch (JsonProcessingException e) {
            logger.error("Failed to serialize log event", e);
        }
    }
}

Mapped Diagnostic Context (MDC)

MDC enables correlation of log entries across multiple threads and systems. I’ve found it particularly valuable in microservices architectures.

public class MDCFilter implements Filter {
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) {
        String correlationId = extractOrGenerateCorrelationId(request);
        MDC.put("correlationId", correlationId);
        MDC.put("userIP", request.getRemoteAddr());
        
        try {
            chain.doFilter(request, response);
        } finally {
            MDC.clear();
        }
    }
}

Asynchronous Logging

This pattern prevents logging operations from blocking the main application thread, crucial for high-throughput systems.

public class AsyncLogHandler {
    private static final int QUEUE_SIZE = 10_000;
    private final BlockingQueue<LogEvent> queue = new LinkedBlockingQueue<>(QUEUE_SIZE);
    private final ExecutorService executor = Executors.newSingleThreadExecutor();

    public void start() {
        executor.submit(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    LogEvent event = queue.take();
                    processLogEvent(event);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        });
    }

    public void queueLog(LogEvent event) {
        if (!queue.offer(event)) {
            logger.warn("Logging queue full, dropping log event");
        }
    }
}

Conditional Logging

Smart conditional logging reduces unnecessary log volume while ensuring important information is captured.

public class SmartLogger {
    private static final Logger logger = LoggerFactory.getLogger(SmartLogger.class);
    private final LoggingConfig config;

    public void logWithDetail(String message, Map<String, Object> details, LogLevel level) {
        if (!isLoggingEnabled(level)) {
            return;
        }

        String formattedMessage = formatMessage(message, details);
        switch (level) {
            case DEBUG:
                logger.debug(formattedMessage);
                break;
            case INFO:
                logger.info(formattedMessage);
                break;
            case WARN:
                logger.warn(formattedMessage);
                break;
            case ERROR:
                logger.error(formattedMessage);
                break;
        }
    }
}

Performance Monitoring

This pattern helps identify performance bottlenecks and track system behavior over time.

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

    public <T> T measureOperation(String operationName, Supplier<T> operation) {
        long startTime = System.nanoTime();
        try {
            T result = operation.get();
            recordMetrics(operationName, startTime);
            return result;
        } catch (Exception e) {
            logFailedOperation(operationName, startTime, e);
            throw e;
        }
    }

    private void recordMetrics(String operation, long startTime) {
        long duration = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime);
        logger.info("Operation {} completed in {} ms", operation, duration);
    }
}

Error Context Logging

Enhanced error logging captures the full context needed for debugging production issues.

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

    public void logException(Throwable error, Map<String, Object> context) {
        Map<String, Object> errorContext = new HashMap<>(context);
        errorContext.put("timestamp", LocalDateTime.now());
        errorContext.put("thread", Thread.currentThread().getName());
        errorContext.put("errorType", error.getClass().getName());
        errorContext.put("stackTrace", getStackTraceAsString(error));

        logger.error("Application error: {}", error.getMessage(), errorContext);
    }
}

Sampling Logger

This pattern helps manage log volume in high-throughput scenarios while maintaining representative data.

public class SampledLogger {
    private final AtomicLong counter = new AtomicLong();
    private final int sampleRate;
    private final Random random = new Random();

    public void logWithSampling(String message, Map<String, Object> data) {
        if (shouldSample()) {
            logger.info("Sampled log: {} - Data: {}", message, data);
        }
    }

    private boolean shouldSample() {
        return counter.incrementAndGet() % sampleRate == 0 || 
               random.nextDouble() < 0.01; // 1% random sampling
    }
}

These patterns form a comprehensive logging strategy for production applications. I’ve implemented them in various combinations depending on specific requirements. The key is to balance information richness with system performance and maintenance costs.

Regular review and adjustment of logging patterns ensure they continue to serve their purpose as applications evolve. Proper implementation of these patterns has helped me identify and resolve production issues quickly, often before they impact users.

Remember to configure appropriate log rotation and retention policies, and consider log aggregation solutions that can handle structured data effectively. These practices ensure logs remain valuable tools rather than operational burdens.