fmtlog vs spdlog: which is faster?

fmtlog has lower latency (nanoseconds vs microseconds) and higher throughput than spdlog, but requires explicit polling for asynchronous logging, whereas spdlog handles threading automatically.

How to set up fmtlog in a multi-threaded application?

Call fmtlog::poll() periodically from a single thread, or use fmtlog::startPollingThread(interval) to create a background thread. Each logging thread gets its own queue to avoid contention.

Does fmtlog support log file rotation?

No, fmtlog does not have built-in log rotation. You must implement custom file management or periodically call fmtlog::setLogFile() to switch files manually.

What happens when the log queue is full?

By default, logs are dropped, but you can define FMTLOG_BLOCK=1 to block or set a callback with fmtlog::setLogQFullCB() to handle overflow, as explained in the performance section.

Can fmtlog output to syslog?

Not directly, but you can use fmtlog::setLogCB() to register a callback function that forwards log messages to syslog or other external systems in real-time.

How to reduce memory overhead in fmtlog?

Use FMTLOG_ONCE macros for infrequent logs to avoid static table entries, or disable runtime level checks with FMTLOG_NO_CHECK_LEVEL to reduce code size, as noted in the README.

Open-Awesome

fmtlog

MITC++v2.3.0

A high-performance asynchronous C++ logging library using fmtlib formatting with nanosecond latency.

GitHub

1.0k stars157 forks0 contributors

What is fmtlog?

fmtlog is a high-performance asynchronous logging library for C++ that uses fmtlib-style formatting. It solves the need for extremely fast logging in latency-sensitive applications by providing nanosecond-scale front-end operations while maintaining rich, type-safe log formatting.

Target Audience

C++ developers building performance-critical applications such as high-frequency trading systems, game engines, or real-time services where logging overhead must be minimized.

Value Proposition

Developers choose fmtlog for its unique combination of fmtlib's expressive formatting, lower latency than NanoLog, higher throughput than spdlog, and fine-grained control over threading and buffering without hidden background threads.

Overview

fmtlog is a performant fmtlib-style logging library with latency in nanoseconds.

Use Cases

Best For

High-frequency trading systems requiring nanosecond-precision logging
Real-time game engines where logging overhead impacts frame rates
Low-latency server applications that cannot tolerate logging delays
Embedded systems or performance-sensitive C++ projects needing header-only logging
Applications requiring rich, type-safe log formatting with custom types
Multi-threaded services that need guaranteed chronological log ordering

Not Ideal For

Applications requiring synchronous, immediate log output without any polling or background thread management
Projects with strict memory budgets where ~50 bytes per log statement code bloat is prohibitive
Teams needing built-in log rotation, color output, or syslog integration without custom code
Environments using compilers or platforms not explicitly supported (e.g., macOS or older C++ standards)

Pros & Cons

Pros

Nanosecond-Scale Latency

Benchmarks show front-end operations in single-digit nanoseconds, outperforming NanoLog and spdlog for most message types, as detailed in the performance section.

Rich fmtlib Formatting

Leverages fmtlib for type-safe format strings, supporting custom types, ranges, tuples, and user-defined formatters, enabling expressive log messages.

Flexible Threading Control

Allows explicit polling via fmtlog::poll() or background thread creation, giving developers full control over logging thread management for predictable behavior.

Guaranteed Chronological Order

Asynchronous multi-threaded logging ensures logs are output in time order, critical for debugging concurrent applications without race conditions.

Cons

Explicit Polling Overhead

Requires manual calls to fmtlog::poll() or background thread setup, adding complexity and potential points of failure in application code.

Code Size Bloat

Each log statement adds approximately 50 bytes for decoding functions, significantly increasing binary size in log-heavy applications, as admitted in the README.

Limited Built-in Features

Lacks native support for color output, log rotation, or syslog, requiring custom implementations via callbacks or external handling.

Frequently Asked Questions

Related Projects

spdlog

Fast C++ logging library.

Stars29,586

Forks5,404

Last commit3 days ago

glog

C++ implementation of the Google logging module

Stars7,395

Forks2,247

Last commit1 year ago

Easylogging++

C++ logging library. It is powerful, supports asynchronous low latency, extendable, light-weight, fast performing, thread and type safe and consists of many built-in features. It provides ability to write logs in your own customized format. It also provide support for logging your classes, third-party libraries, STL and third-party containers etc.

Stars3,938

Forks944