Go to file
2016-08-21 01:21:18 +03:00
bench no streams 2016-07-08 17:50:13 +03:00
cmake no streams 2016-07-08 17:50:13 +03:00
example updated example 2016-08-21 01:21:18 +03:00
include/spdlog Added support for syslog in FreeBSD 2016-08-21 01:16:04 +03:00
tests atyle 2016-08-20 13:55:50 +03:00
.gitignore updated .gtiignore and example vcxproj file 2016-07-22 19:07:24 +03:00
.travis.yml Update .travis.yml 2016-06-18 15:31:45 +03:00
astyle.sh astyle 2014-12-21 02:47:04 +02:00
CMakeLists.txt Update CMakeLists.txt 2016-07-10 00:08:43 +03:00
INSTALL no streams 2016-07-08 17:50:13 +03:00
LICENSE no streams 2016-07-08 17:50:13 +03:00
README.md Update README.md 2016-08-20 14:11:56 +03:00

spdlog

Very fast, header only, C++ logging library. Build Status  Build status

Install

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

Platforms

  • Linux (gcc 4.8.1+, clang 3.5+)
  • Windows (visual studio 2013+, cygwin/mingw with g++ 4.9.1+)
  • Mac OSX (clang 3.5+)

##Features

  • Very fast - performance is the primary goal (see benchmarks below).
  • Headers only.
  • No dependencies - just copy and use.
  • Feature rich call style using the excellent fmt library.
  • 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 (colors supported).
    • 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.

Benchmarks

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

Synchronous mode

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

threads boost log 1.54 glog easylogging spdlog
1 4.169s 1.066s 0.975s 0.302s
10 6.180s 3.032s 2.857s 0.968s
100 5.981s 1.139s 4.512s 0.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):

threads g2log async logger spdlog async mode
1 1.850s 0.216s
10 0.943s 0.173s
100 0.959s 0.202s

Usage Example

//
// Copyright(c) 2015 Gabi Melman.
// Distributed under the MIT License (http://opensource.org/licenses/MIT)
//
//
// spdlog usage example
//
#include "spdlog/spdlog.h"

#include <iostream>
#include <memory>

void async_example();
void syslog_example();
void user_defined_example();
void err_handler_example();

namespace spd = spdlog;
int main(int, char*[])
{
    try
    {
        // Multithreaded color console
        auto console = spd::stdout_logger_mt("console", true);
        console->info("Welcome to spdlog!");
        console->error("An info message example {}..", 1);

        // Formatting examples
        console->warn("Easy padding in numbers like {:08d}", 12);
        console->critical("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");

        console->info("{:<30}", "left aligned");
        console->info("{:>30}", "right aligned");
        console->info("{:^30}", "centered");

        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");

        // 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("This message shold be displayed..");

        // Create basic file logger (not rotated)
        auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic.txt");
        my_logger->info("Some log message");


        // Create a file rotating logger with 5mb size max and 3 rotated files
        auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/mylogfile", 1048576 * 5, 3);
        for (int i = 0; i < 10; ++i)
            rotating_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);
        daily_logger->info(123.44);

        // Customize msg format for all messages
        spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
        rotating_logger->info("This is another message with custom format");

        // 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..
        async_example();

        // syslog example. linux/osx only..
        syslog_example();

        // Log user-defined types example..
        user_defined_example();

        // Change default log error handler
        err_handler_example();

        // Apply a function on all registered loggers
        spd::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->info("End of example."); });
	
        // Release and close all loggers
        spdlog::drop_all();
    }
	// Exceptions will only be thrown upon failed logger or sink construction (not during logging)
    catch (const spd::spdlog_ex& ex)
    {
        std::cout << "Log init failed: " << ex.what() << std::endl;
        return 1;
    }    
}

void async_example()
{
    size_t q_size = 4096; //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");
    for (int i = 0; i < 100; ++i)
        async_file->info("Async message #{}", i);
}

//syslog example (linux/osx only)
void syslog_example()
{
#if defined (__linux__) || defined(__APPLE__)
    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
}

// user defined types logging by implementing operator<<
struct my_type
{
    int i;
    template<typename OStream>
    friend OStream& operator<<(OStream& os, const my_type &c)
    {
        return os << "[my_type i="<<c.i << "]";
    }
};

#include <spdlog/fmt/ostr.h> // must be included
void user_defined_example()
{
    spd::get("console")->info("user defined type: {}", my_type { 14 });
}

//
//custom error handler
//
void err_handler_example()
{	
	spdlog::set_error_handler([](const std::string& msg) {
		std::cerr << "my err handler: " << msg << std::endl;
	}); 
	// (or logger->set_error_handler(..) to set for specific logger)
}

Documentation

Documentation can be found in the wiki pages.