+

+spdlog

Very fast, header only, C++ logging library.

-Install

+Install

Just copy the files to your build tree and use a C++11 compiler

-Tested on:

+Tested on:
  • gcc 4.8.1 and above
    • -
  • clang 3.5
    • +
  • clang 3.5 (Linux and OSX)
  • visual studio 2013
    • +
  • mingw with g++ 4.9.x

-Features

+Features
    -
  • Very low overhead
    • -
  • Stream like, easy to use interface
    • -
  • Logging levels
    • -
  • Rotating log files
    • -
  • Daily log files
    • -
  • Async logging
    • -
  • Thread safety
    • -
  • Custom formatting
    • +
  • Very fast - performance is the primary goal (see benchmarks below).
    • +
  • Headers only.
    • +
  • No dependencies - just copy and use.
    • +
  • Cross platform - Linux / Windows on 32/64 bits.
    • +
  • +new! Feature rich call style using the excellent cppformat library.
    • +
  • ostream call style is supported too.
    • +
  • Extremely fast asynchronous mode (optional) - using lockfree queues and other tricks to reach millions of calls/sec.
    • +
  • +Custom formatting.
    • +
  • Multi/Single threaded loggers.
    • +
  • Various log targets: + +
      +
    • Rotating log files.
      • +
    • Daily log files.
      • +
    • Console logging.
      • +
    • Linux syslog.
      • +
    • Easily extendable with custom log targets (just implement a single function in the sink interface).
      • +
    +
    • +
  • Severity based filtering - threshold levels can be modified in runtime as well as in compile time.

-Performance

+Benchmarks -

The library is very fast. -Here are some benchmarks (Ubuntu, Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz)

+

Below are some benchmarks comparing popular log libraries under Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz

-
*******************************************************************************
-Single thread, 250,000 iterations, flush every 1000 lines
-*******************************************************************************
-rotating_st...  817,860 lines/sec
-daily_st...     827,820 lines /sec
+

+Synchronous mode

 
-*******************************************************************************
-4 threads sharing same logger, 250,000 iterations, flush every 1000 lines
-*******************************************************************************
-rotating_mt...  1,476,013 lines/sec
-daily_mt...     1,477,619 lines/sec
-
+

Time needed to log 1,000,000 lines in synchronous mode (in seconds, the best of 3 runs):

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
threadsboost logglogeasyloggingspdlog
14.169s1.066s0.975s0.302s
1016.0293.032s2.857s0.968s
10015.0081.139s4.512s0.497s
+ +

+Asynchronous mode

+ +

Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes to put them in the async queue (in seconds, the best of 3 runs):

+ + + + + + + + + + + + + + + + + + + + + + + + + + +
threadsg2log async logger +spdlog async mode +
11.850s0.216s
100.943s0.173s
1000.959s0.202s

-Usage Example

+Usage Example -
#include <iostream>
-#include "spdlog/spdlog.h"
+
#include <iostream>
+#include "spdlog/spdlog.h"
 
-int main(int, char* [])
+int main(int, char* [])
 {
-    namespace spd = spdlog;
-
-    try
+    namespace spd = spdlog;
+    try
     {
-        std::string filename = "spdlog_example";
-        auto console = spd::stderr_logger_mt("console");
-        console->info("Welcome to spdlog!") ;
-        console->info() << "Creating file " << filename << "..";
+        //Create console, multithreaded logger
+        auto console = spd::stdout_logger_mt("console");
+        console->info("Welcome to spdlog!") ;
+        console->info("An info message example {}..", 1);
+        console->info() << "Streams are supported too  " << 1;
 
-        auto file_logger = spd::rotating_logger_mt("file_logger", filename, 1024 * 1024 * 5, 3);
-        file_logger->info("Log file message number", 1);
+        //Formatting examples
+        console->info("Easy padding in numbers like {:08d}", 12);
+        console->info("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
+        console->info("Support for floats {:03.2f}", 1.23456);
+        console->info("Positional args are {1} {0}..", "too", "supported");
 
-        for (int i = 0; i < 100; ++i)
-        {
-            auto square = i*i;
-            file_logger->info() << i << '*' << i << '=' << square << " (" << "0x" << std::hex << square << ")";
-        }
+        console->info("{:<30}", "left aligned");
+        console->info("{:>30}", "right aligned");
+        console->info("{:^30}", "centered");
 
-        // Change log level to all loggers to warning and above
-        spd::set_level(spd::level::WARN);
-        console->info("This should not be displayed");
-        console->warn("This should!");
-        spd::set_level(spd::level::INFO);
+        //
+        // Runtime log levels
+        //
+        spd::set_level(spd::level::info); //Set global log level to info
+        console->debug("This message shold not be displayed!");
+        console->set_level(spd::level::debug); // Set specific logger's log level
+        console->debug("Now it should..");
 
-        // Change format pattern to all loggers
-        spd::set_pattern(" **** %Y-%m-%d %H:%M:%S.%e %l **** %v");
-        spd::get("console")->info("This is another message with different format");
+        //
+        // Create a file rotating logger with 5mb size max and 3 rotated files
+        //
+        auto file_logger = spd::rotating_logger_mt("file_logger", "logs/mylogfile", 1048576 * 5, 3);
+        for(int i = 0; i < 10; ++i)
+              file_logger->info("{} * {} equals {:>10}", i, i, i*i);
+
+        //
+        // Create a daily logger - a new file is created every day on 2:30am
+        //
+        auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30);
+
+        // 
+        // Customize msg format for all messages
+        //
+        spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
+        file_logger->info("This is another message with custom format");
+
+        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");
+
+        //
+        // Compile time debug or trace macros.
+        // Enabled #ifdef SPDLOG_DEBUG_ON or #ifdef SPDLOG_TRACE_ON
+        //
+        SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
+        SPDLOG_DEBUG(console, "Enabled only #ifdef SPDLOG_DEBUG_ON.. {} ,{}", 1, 3.23);
+
+        //
+        // Asynchronous logging is very fast..
+        // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous..
+        //
+        size_t q_size = 1048576; //queue size must be power of 2
+        spdlog::set_async_mode(q_size);
+        auto async_file= spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
+        async_file->info() << "This is async log.." << "Should be very fast!";
+
+        //      
+        // syslog example. linux only..
+        //
+        #ifdef __linux__
+        std::string ident = "spdlog-example";
+        auto syslog_logger = spd::syslog_logger("syslog", ident, LOG_PID);
+        syslog_logger->warn("This is warning that will end up in syslog. This is Linux only!");       
+        #endif
     }
-    catch (const spd::spdlog_ex& ex)
+    catch (const spd::spdlog_ex& ex)
     {
-        std::cout << "Log failed: " << ex.what() << std::endl;
+        std::cout << "Log failed: " << ex.what() << std::endl;
     }
-    return 0;
 }
-

-