Log levels (TRACE, DEBUG, INFO, WARN, ERROR) in Spring Boot - Deep Dive

Overview - Log levels (TRACE, DEBUG, INFO, WARN, ERROR)

What is it?

Log levels are categories that tell us how important or detailed a message in a log is. They help developers and system administrators understand what is happening inside an application. Common log levels include TRACE, DEBUG, INFO, WARN, and ERROR, each showing different detail and urgency. These levels help filter logs so you see only what you need.

Why it matters

Without log levels, logs would be a confusing flood of messages, making it hard to find real problems or understand system behavior. Log levels let you control how much detail you see, saving time and helping fix issues faster. They also help keep systems running smoothly by avoiding too much logging that can slow down applications or fill storage.

Where it fits

Before learning log levels, you should understand basic logging concepts and why applications record events. After mastering log levels, you can learn about configuring logging frameworks in Spring Boot, log formatting, and advanced monitoring tools that use logs.

Mental Model

Core Idea

Log levels are like volume controls for messages, letting you hear only the important sounds or all the quiet details depending on your need.

Think of it like...

Imagine you are at a party. TRACE is like hearing every whisper, DEBUG is hearing all conversations, INFO is hearing announcements, WARN is hearing someone raising their voice to warn, and ERROR is hearing someone shouting about a problem.

┌─────────────┐
│   TRACE     │  Most detailed, very noisy
├─────────────┤
│   DEBUG     │  Detailed for developers
├─────────────┤
│   INFO      │  General system info
├─────────────┤
│   WARN      │  Something might be wrong
├─────────────┤
│   ERROR     │  Something is broken
└─────────────┘

Build-Up - 7 Steps

1

Foundation

What is Logging in Applications

Concept: Logging means recording messages about what an application is doing.

Applications write logs to record events like starting up, processing data, or errors. Logs help developers understand how the app behaves and find problems. Without logs, it is like trying to fix a car without any dashboard or sounds.

Result

You understand why applications create logs and what they are used for.

Knowing that logs are the application's way of telling its story helps you appreciate why organizing these messages matters.

2

Foundation

Introduction to Log Levels

Concept: Log levels categorize messages by importance and detail.

Not all messages are equally important. Some are tiny details, others are warnings or errors. Log levels let you mark messages so you can choose to see only the important ones or all details. Common levels are TRACE, DEBUG, INFO, WARN, and ERROR.

Result

You can identify different log levels and their purpose.

Understanding that log levels act like filters helps you control what you see in logs.

3

Intermediate

Detailed Meaning of Each Log Level

🤔Before reading on: do you think ERROR logs include warnings or only critical failures? Commit to your answer.

Concept: Each log level has a specific meaning and use case.

TRACE logs show every tiny step, useful for deep debugging but very noisy. DEBUG logs show detailed info for developers. INFO logs show normal operations like startup or shutdown. WARN logs indicate something unexpected but not fatal. ERROR logs show serious problems that need fixing.

Result

You can decide which log level to use for different messages.

Knowing the exact meaning of each level prevents misuse and helps keep logs clear and useful.

4

Intermediate

Configuring Log Levels in Spring Boot

🤔Before reading on: do you think setting log level to INFO will show DEBUG messages? Commit to your answer.

Concept: Spring Boot lets you set the minimum log level to control what messages appear.

In Spring Boot, you can set log levels in application.properties or application.yml using keys like 'logging.level.root=INFO'. Messages below the set level are hidden. For example, setting INFO hides DEBUG and TRACE messages. You can also set levels per package or class.

Result

You can configure which log messages your Spring Boot app shows.

Understanding how to configure log levels lets you balance detail and noise in logs.

5

Intermediate

Using Log Levels to Troubleshoot Problems

🤔Before reading on: do you think increasing log detail always helps find bugs faster? Commit to your answer.

Concept: Choosing the right log level helps find issues without overwhelming you with data.

When debugging, you might set log level to DEBUG or TRACE to see detailed info. In production, you usually use INFO or WARN to avoid too much data. Too much logging can slow the app or fill disk space. Good practice is to increase detail only when needed.

Result

You know when and how to change log levels to solve problems efficiently.

Knowing when to increase or decrease log detail saves time and resources.

6

Advanced

Log Level Hierarchy and Filtering Mechanism

🤔Before reading on: do you think setting a log level filters out messages above or below that level? Commit to your answer.

Concept: Log levels form a hierarchy where setting a level shows messages at that level and above.

Log levels are ordered: TRACE < DEBUG < INFO < WARN < ERROR. Setting a level means showing messages at that level and higher severity. For example, setting WARN shows WARN and ERROR but hides INFO, DEBUG, and TRACE. This filtering happens inside the logging framework before messages are saved or displayed.

Result

You understand how log level filtering works internally.

Understanding the hierarchy prevents confusion about which messages appear at each setting.

7

Expert

Performance Impact and Best Practices of Log Levels

🤔Before reading on: do you think logging at TRACE level in production has no performance cost? Commit to your answer.

Concept: Logging detail affects application speed and resource use; best practices balance detail and performance.

Logging at very detailed levels like TRACE or DEBUG can slow down applications because of extra processing and disk use. In production, use INFO or higher to avoid this. Also, avoid expensive operations inside log statements unless the log level is enabled. Many logging frameworks support conditional logging to help with this.

Result

You can write efficient logging code that avoids slowing down your app.

Knowing the performance cost of logging detail helps you write better, faster applications.

Under the Hood

Logging frameworks in Spring Boot use a chain of components: the application code calls a logger method with a level and message. The logger checks the configured minimum level. If the message level is equal or higher, it formats the message and sends it to appenders (console, file, etc.). Otherwise, it ignores the message. This filtering avoids unnecessary work for low-level messages when not needed.

Why designed this way?

This design balances flexibility and performance. Early logging systems wrote every message, causing huge logs and slowdowns. Introducing levels and filtering lets developers control detail and avoid overhead. The hierarchy and configuration per package allow fine control. Alternatives like no filtering or fixed levels were too rigid or inefficient.

Application Code
    │
    ▼
Logger Method Call (with level)
    │
    ▼
Check Configured Level ──> If message level < config level: discard
    │
    ▼
Format Message
    │
    ▼
Send to Appenders (console, file, remote)
    │
    ▼
Message Stored or Displayed

Myth Busters - 4 Common Misconceptions

Quick: Does setting log level to ERROR show WARN messages? Commit to yes or no.

Common Belief: Setting log level to ERROR will show all messages including WARN and INFO.

Reality: Setting log level to ERROR only shows ERROR messages and hides WARN, INFO, DEBUG, and TRACE.

Why it matters: Misunderstanding this causes missing important warnings or info messages when debugging production issues.

Quick: Do TRACE and DEBUG levels have the same detail? Commit to yes or no.

Common Belief: TRACE and DEBUG are the same level of detail, just different names.

Reality: TRACE is more detailed than DEBUG, showing even finer-grained information.

Why it matters: Confusing these levels can lead to either too much or too little logging detail during troubleshooting.

Quick: Does logging at TRACE level in production have no performance impact? Commit to yes or no.

Common Belief: Logging at TRACE level is harmless and can be left on all the time.

Reality: TRACE logging can significantly slow down applications and increase storage use.

Why it matters: Leaving TRACE on in production can degrade performance and cause resource exhaustion.

Quick: Does changing log level in Spring Boot require code changes? Commit to yes or no.

Common Belief: You must change code to adjust log levels.

Reality: Log levels can be changed via configuration files or environment variables without code changes.

Why it matters: Not knowing this leads to unnecessary code redeployments and slower troubleshooting.

Expert Zone

1

Log levels can be set per package or class, allowing fine-grained control over logging detail in different parts of an application.

2

Some logging frameworks support markers or tags that add extra context beyond levels, enabling more precise filtering.

3

Conditional logging (checking if a level is enabled before building complex log messages) prevents wasted CPU cycles and memory allocations.

When NOT to use

Using very detailed log levels like TRACE or DEBUG in high-throughput production systems is usually wrong due to performance costs. Instead, use monitoring tools or sampling logs. For critical errors, use alerting systems rather than relying solely on logs.

Production Patterns

In production, teams often set root log level to INFO or WARN and increase to DEBUG or TRACE temporarily when investigating issues. Logs are centralized using tools like ELK stack or Splunk, and log rotation is configured to manage disk space.

Connections

Event Monitoring Systems

Log levels build on the idea of categorizing events by importance, similar to how monitoring systems prioritize alerts.

Understanding log levels helps grasp how monitoring tools filter and escalate system events.

Human Attention Management

Log levels mirror how humans prioritize information, focusing on urgent or important signals and ignoring noise.

Knowing this connection explains why filtering logs by level is essential to avoid overload.

Traffic Light System

Log levels correspond to traffic light colors: INFO is green (normal), WARN is yellow (caution), ERROR is red (stop).

This helps understand the urgency and action needed for each log level.

Common Pitfalls

#1 Logging everything at ERROR level to avoid missing messages.

Wrong approach:

logger.error("User login attempt");
logger.error("Data processed successfully");

Correct approach:

logger.info("User login attempt");
logger.debug("Data processed successfully");

Root cause:

Misunderstanding that ERROR is only for serious problems leads to overusing it and losing log usefulness.

#2 Building complex log messages without checking if the log level is enabled.

Wrong approach:

logger.debug("User data: " + expensiveToString(user));

Correct approach:

if (logger.isDebugEnabled()) {
logger.debug("User data: " + expensiveToString(user));
}

Root cause:

Not realizing that string concatenation or method calls happen even if the message is not logged wastes resources.

#3 Setting log level to TRACE in production and forgetting to revert.

Wrong approach:

logging.level.root=TRACE

Correct approach:

logging.level.root=INFO

Root cause:

Forgetting to adjust log level after debugging causes performance and storage issues.

Key Takeaways

Log levels organize messages by importance, helping you focus on what matters.

Each level from TRACE to ERROR has a clear purpose and should be used accordingly.

Spring Boot lets you configure log levels easily without changing code.

Using the right log level balances detail and performance, especially in production.

Misusing log levels or ignoring performance impacts can cause serious issues.