# How to Use Abseil C++ Flags for Runtime Logging Configuration

> Learn how to use Abseil C++ flags to configure logging at runtime. Easily manage log behavior with command-line arguments parsed by absl ParseCommandLine.

- Repository: [Abseil/abseil-cpp](https://github.com/abseil/abseil-cpp)
- Tags: how-to-guide
- Published: 2026-07-15

---

**Abseil C++ flags enable runtime configuration of logging behavior via command-line arguments parsed through `absl::ParseCommandLine()` before initializing the logging subsystem with `absl::InitializeLog()`.**

The Abseil logging library in the `abseil/abseil-cpp` repository supports dynamic configuration through a dedicated set of command-line flags. When you link the `//absl/log:flags` target and invoke the flag parser before log initialization, you can control severity thresholds, verbosity levels, and output formatting without recompiling your application.

## Available Abseil C++ Logging Flags

The logging flags are declared in [`absl/log/internal/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/internal/flags.h) and exposed through the public header [`absl/log/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/flags.h). When the `//absl/log:flags` target is linked into your binary, the following flags become available:

- **`--stderrthreshold`** (int, default: `ERROR`): Messages with severity greater than or equal to this level are also written to *stderr* in addition to any registered `LogSink`s.
- **`--minloglevel`** (int, default: `INFO`): Messages with severity less than this level are completely discarded.
- **`--log_backtrace_at`** (string, default: empty): When specified as `<file>:<line>`, any log emitted from that exact location includes a backtrace.
- **`--log_prefix`** (bool, default: `true`): Controls whether the standard log prefix (severity, timestamp, PID, etc.) is printed.
- **`--v`** (int, default: `0`): Global verbosity level; higher values enable more detailed `VLOG()` output.
- **`--vmodule`** (string, default: empty): Per-module verbosity control using comma-separated patterns (e.g., `--vmodule=foo=2,bar=1`).

> **Important:** These flags are intended strictly for command-line use. For programmatic configuration, use the APIs in [`absl/log/globals.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/globals.h) such as `absl::SetStderrThreshold()` and `absl::SetMinLogLevel()`. The flag declarations are deliberately placed in an internal header to discourage direct use in C++ code.

## Linking and Initialization Order

To use Abseil C++ flags, you must link the `absl_log_flags` target and initialize the flag parser before the logging system.

### Build Configuration

When building with Bazel, add the target to your dependencies:

```bash
bazel build //myapp:my_binary --linkopt=-labsl_log_flags

```

For CMake or other build systems, link against the `absl_log_flags` library target.

### Runtime Initialization

The critical sequence is parsing flags before initializing logs:

```cpp
#include "absl/log/flags.h"
#include "absl/log/globals.h"
#include "absl/flags/parse.h"

int main(int argc, char *argv[]) {
  // Parse all Abseil flags, including logging ones.
  absl::ParseCommandLine(argc, argv);
  
  // Initialize logging after flag parsing.
  absl::InitializeLog();

  // Application logic proceeds here.
  LOG(INFO) << "Application started with configured flags";
  return 0;
}

```

Calling `absl::ParseCommandLine(argc, argv)` before `absl::InitializeLog()` ensures that flag values are applied to the logging subsystem at startup.

## Practical Command-Line Examples

Controlling stderr output requires adjusting the threshold:

```bash
./my_binary --stderrthreshold=WARNING

```

This configuration ensures only `WARNING`, `ERROR`, and `FATAL` messages appear on `stderr`, while lower-severity logs route only to registered sinks.

To completely disable logs below a certain severity:

```bash
./my_binary --minloglevel=ERROR

```

With this setting, `INFO` and `WARNING` calls become no-ops, optimizing performance for production environments.

For debugging specific locations:

```bash
./my_binary --log_backtrace_at=my_file.cc:123

```

When a log statement executes at line 123 of `my_file.cc`, the output automatically includes a full stack trace.

Verbosity control combines global and module-specific settings:

```bash
./my_binary --v=2 --vmodule=network=3,ui=1

```

This sets the global verbosity level to 2 while overriding specific modules: `network` operates at level 3 and `ui` at level 1.

## Programmatic Configuration Alternative

While Abseil C++ flags provide runtime flexibility, programmatic configuration offers compile-time control through [`absl/log/globals.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/globals.h):

- `absl::SetStderrThreshold(absl::LogSeverity)`: Equivalent to `--stderrthreshold`
- `absl::SetMinLogLevel(absl::LogSeverity)`: Equivalent to `--minloglevel`

These functions apply immediately without requiring command-line parsing, making them suitable for library code or environments where command-line arguments are restricted.

## Key Source Files and Implementation

Understanding the source structure helps navigate the codebase:

| File | Purpose |
|------|---------|
| [`absl/log/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/flags.h) | Public header re-exporting flag declarations for user inclusion |
| [`absl/log/internal/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/internal/flags.h) | Internal declarations using `ABSL_DECLARE_FLAG` macros |
| [`absl/log/globals.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/globals.h) | Programmatic getters and setters for logging configuration |
| [`absl/flags/parse.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/flags/parse.h) | Command-line flag parsing implementation |
| `absl/log/flags_test.cc` | Unit tests demonstrating flag behavior and edge cases |

The internal implementation in [`absl/log/internal/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/internal/flags.h) defines the actual flag variables, while [`absl/log/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/flags.h) provides the supported public interface. The parsing logic lives in [`absl/flags/parse.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/flags/parse.h), which processes arguments before `absl::InitializeLog()` consumes them.

## Summary

- Link the `//absl/log:flags` target to enable logging flags in your binary.
- Call `absl::ParseCommandLine(argc, argv)` before `absl::InitializeLog()` to apply command-line settings.
- Use flags like `--stderrthreshold`, `--minloglevel`, and `--vmodule` to control output without recompiling.
- Prefer [`absl/log/globals.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/globals.h) APIs for programmatic configuration inside library code.
- Reference [`absl/log/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/flags.h) for the public interface and [`absl/log/internal/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/internal/flags.h) for implementation details.

## Frequently Asked Questions

### How do I disable Abseil logging flags if I want only programmatic control?

Simply omit the `//absl/log:flags` target from your build dependencies. Without this target linked, the command-line flags are not registered, and you retain full control through the [`absl/log/globals.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/globals.h) API.

### What happens if I call `absl::InitializeLog()` before `absl::ParseCommandLine()`?

The logging subsystem initializes with default values (e.g., `--stderrthreshold=ERROR`), and subsequent flag parsing has no effect on the already-initialized configuration. Always parse flags first to ensure your command-line settings take effect.

### Can I use Abseil C++ flags in a library that doesn't own `main()`?

While you can include [`absl/log/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/flags.h) in library code, the flags are designed for application-level configuration. Libraries should use the programmatic APIs in [`absl/log/globals.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/globals.h) to avoid polluting the global flag namespace or interfering with the application's command-line parsing.

### Where are the default values for logging flags defined?

Default values are specified in [`absl/log/internal/flags.h`](https://github.com/abseil/abseil-cpp/blob/main/absl/log/internal/flags.h) using the `ABSL_FLAG` macro. For example, the `stderrthreshold` flag defaults to `absl::LogSeverity::kError` and `minloglevel` defaults to `absl::LogSeverity::kInfo` as defined in the internal implementation.