# What Are the Different Log Levels Supported by spdlog? A Complete Guide

> Explore the seven log levels in spdlog trace debug info warn err critical off. Gain granular control over your C++ application logging verbosity with this complete guide.

- Repository: [Gabi Melman/spdlog](https://github.com/gabime/spdlog)
- Tags: how-to-guide
- Published: 2026-07-22

---

**spdlog defines seven distinct log levels—trace, debug, info, warn, err, critical, and off—through the `level::level_enum` enumeration in [`include/spdlog/common.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/common.h), allowing granular control over logging verbosity.**

The `gabime/spdlog` library provides a robust severity-based filtering system centered around these log levels. According to the spdlog source code, the enumeration declared at lines 47–55 of [`include/spdlog/common.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/common.h) serves as the foundation for all logging threshold decisions, from individual loggers to specific output sinks.

## The Seven Log Levels Defined in [`common.h`](https://github.com/gabime/spdlog/blob/main/common.h)

The heart of spdlog's severity system resides in the `level::level_enum` definition. This scoped enumeration assigns integer values to each severity level and provides the basis for compile-time constants like `SPDLOG_LEVEL_TRACE`.

### Understanding `level::level_enum`

In [`include/spdlog/common.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/common.h) (lines 47–55), the enum declares the following levels in ascending order of severity:

- **`trace`** – Detailed debugging information for tracing execution flow; the lowest severity level.
- **`debug`** – General debugging messages useful during development.
- **`info`** – Normal operational messages indicating the application is functioning as expected.
- **`warn`** – Potentially harmful conditions that do not prevent execution.
- **`err`** – Error events that might still allow the application to continue running but require attention.
- **`critical`** – Severe error events that will likely lead to application failure or termination.
- **`off`** – Special level that disables all logging output.

The enumeration also defines `n_levels` as a sentinel value for internal bounds checking, ensuring level values remain valid throughout the API.

## Configuring Log Levels in Your Application

The library exposes log level configuration through two primary interfaces: the `spdlog::logger` class for per-logger filtering and the `spdlog::sinks::sink` base class for per-sink granularity.

### Setting the Logger Threshold

Use `spdlog::logger::set_level(level::level_enum)` to establish the minimum severity a logger will process. Messages below this threshold are silently discarded.

```cpp
#include <spdlog/spdlog.h>

int main() {
    auto console = spdlog::stdout_color_mt("console");
    
    // Only process warnings and above
    console->set_level(spdlog::level::warn);
    
    // These are filtered out
    console->trace("trace message – not shown");
    console->debug("debug message – not shown");
    console->info("info message – not shown");
    
    // These appear in output
    console->warn("warning message");
    console->error("error message");
    console->critical("critical failure");
    
    // Disable logging entirely
    console->set_level(spdlog::level::off);
    console->error("this will never be printed");
}

```

### Per-Sink Filtering

For advanced scenarios, `spdlog::sinks::sink::set_level(level::level_enum)` allows different outputs to respect different thresholds. This enables patterns like verbose file logging while restricting console output to warnings.

```cpp
auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("app.log");
auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();

file_sink->set_level(spdlog::level::trace);   // Log everything to file
console_sink->set_level(spdlog::level::warn); // Only warnings and above to console

spdlog::logger logger("multi", {file_sink, console_sink});
logger.info("info goes to file, not console");
logger.warn("warning goes to both");

```

## String Representations and Character Codes

Beyond numeric values, spdlog provides human-readable names through `spdlog::level::to_string_view`, mapping each level to its textual name (e.g., "trace", "debug"). Additionally, single-character codes (e.g., "T", "D") are defined in [`include/spdlog/common.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/common.h) (lines 58–79) for compact logging formats. These string conversions facilitate log parsing and formatted output without requiring manual switch statements.

## Summary

- **spdlog supports seven log levels**: trace, debug, info, warn, err, critical, and off, defined in [`include/spdlog/common.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/common.h) at lines 47–55.
- **Configuration occurs at two levels**: Use `spdlog::logger::set_level()` for logger-wide filtering or `spdlog::sinks::sink::set_level()` for individual sink control.
- **The `off` level** completely disables logging output by setting the threshold above critical.
- **String utilities** like `to_string_view` provide human-readable level names and single-character abbreviations as implemented in the source.

## Frequently Asked Questions

### What is the default log level in spdlog?

By default, spdlog initializes loggers to the `info` level, meaning debug and trace messages are suppressed unless explicitly configured otherwise via `set_level()`.

### How do I disable logging completely in spdlog?

Set the logger or sink level to `spdlog::level::off`. This special level, defined in the `level_enum` at [`include/spdlog/common.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/common.h), ensures no messages are processed regardless of their severity.

### Can I set different log levels for different sinks in spdlog?

Yes. As implemented in [`include/spdlog/sinks/sink.h`](https://github.com/gabime/spdlog/blob/main/include/spdlog/sinks/sink.h), each sink maintains its own level threshold via `set_level()`. Create a `spdlog::logger` with multiple sinks, then configure each sink independently to route different severity levels to different destinations.

### What is the difference between `err` and `critical` log levels?

According to the spdlog source code, `err` indicates error conditions that may allow the application to continue, while `critical` represents severe failures that may cause the application to abort. Both are filtered if the threshold is set above them, but `critical` typically warrants immediate attention.