日志管理工具：spdlog 使用

使用说明

简介：spdlog是一款C++专用日志管理工具，其功能全部由头文件实现。https://github.com/gabime/spdlog

安装方法1：使用时只需将头文件放入工程源码中。path：spdlog/include/spdlog
安装方法2：Ubuntu: apt-get install libspdlog-dev
样例程序：参照example/example.cpp，如需测试，直接make-》./example，日志文件输出路径：example/logs

支持功能及使用方法

console-log：控制台输出
//使用控制台输出日志，需要这两个头文件：
#include
#include

//Console logger with color：
auto console = spd::stdout_color_mt(“console”);//“console”为logger名称，可以随意命名。
console->info(“Welcome to spdlog!”);//warn,critical,info 为不同等级的log，输出在控制台会以不同颜色表示。
console->error(“Some error message with arg{}…”, 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”);

//也可以采用 get方法来写入日志：
spd::get(“console”)->info(“loggers can be retrieved from a global registry using the spdlog::get(logger_name) function”);

//release and close all loggers
spdlog::shutdown();

basic-log: 不带滚动，日志文件会一直被写入，不断变大。
// Create basic file logger (not rotated)
auto my_logger = spd::basic_logger_mt(“basic_logger”, “logs/basic-log.txt”);
my_logger->info(“Some log message”);

rotating log:滚动日志，当超出规定大小时，会删除当前日志内容，重新开始写入
//从函数声明可以看出，参数max_file_size 规定了文件的最大值，文件内容超过此值就会清空。

rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files);
参数max_files 规定了滚动文件的个数。当logger_name存满时，将其名称更改为logger_name.1，再新建一个logger_name文件来存储新的日志。
再次存满时，把logger_name.1改名为logger_name.2，logger_name改名为logger_name.1，新建一个logger_name来存放新的日志。max_files 数量为几，
就可以有几个logger_name文件用来滚动。

daily log :每天新建一个日志，新建日志文件时间可以自己定义。
// 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.txt”, 2, 30);
// trigger flush if the log severity is error or higher
daily_logger->flush_on(spd::level::err);
daily_logger->info(123.44);

flush 将buffe刷入文件：遇到指定级别的日志会立马将缓存输出到文件中，如果不立刻写入，当程序发生崩溃或产生异常而退出时，
有些重要log可能还没等写入到文件中。日志的各个级别如下面代码所示：
typedef enum
{
trace = 0,
debug = 1,
info = 2,
warn = 3,
err = 4,
critical = 5,
off = 6
} level_enum;
// trigger flush if the log severity is error or higher
daily_logger->flush_on(spd::level::err);
daily_logger->info(123.44);
daily_logger->error("Error happended! ");

自定义日志格式：官方语法说明：https://github.com/gabime/spdlog/wiki/3.-Custom-formatting
auto rotating_logger = spd::rotating_logger_mt(“some_logger_name”, “logs/rotating.txt”, 256, 2);
// 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”);
//Customize msg format for a specific logger object:
rotating_logger->set_pattern("[%H:%M:%S %f] [thread %t] %v ***");

设置日志级别：低于设置级别的日志将不会被输出。各level排序，数值越大级别越高：
// Runtime log levels
spd::set_level(spd::level::info); //Set global log level to info
console->debug(“This message should not be displayed!”);
console->set_level(spd::level::debug); // Set specific logger’s log level
console->debug(“This message should be displayed…”);

编译阶段修改日志输出级别 SPDLOG_TRACE 和SPDLOG_DEBUG：官方参考：https://github.com/gabime/spdlog/wiki/8.-Tweaking
//当定义了宏定义 SPDLOG_TRACE_ON 时，可以用SPDLOG_TRACE语句输出trace级别的log，SPDLOG_DEBUG_ON也是同理。
#define SPDLOG_TRACE_ON
#define SPDLOG_DEBUG_ON
// Compile time log levels
// define SPDLOG_DEBUG_ON or 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);
需要注意的是，如果不使用set_level命令设置log的输出级别，默认级别就是info级别，此时即使定义了这两个宏，debug和trace信息也不会输出。
所以使用时需要先用set_level把级别设为trace才可以。

console->set_level(spd::level::trace); // Set specific logger’s log level
// Compile time log levels
// define SPDLOG_DEBUG_ON or 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);

处理spd异常 ：官方说明：https://github.com/gabime/spdlog/wiki/Error-handling
当输出日志时发生异常时，spdlog会向std::err 打印一条语句，为了避免输出的异常语句刷屏，打印频率被限制在每分钟一条。
下面函数执行时，由于最后一条输出log的语句中四个参数只给了一个，所以spdlog调用了异常处理函数，输出异常。

void err_handler_example()
{
//can be set globaly or per logger(logger->set_error_handler(…))
spdlog::set_error_handler([](const std::string& msg)
{
std::cerr << "my err handler: " << msg << std::endl;
});
spd::get(“console”)->info(“some invalid message to trigger an error {}{}{}{}”, 3);
}

----------------------------------------------------------以下为官方说明--------------------------------------------

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

Install

Just copy the headers:

Copy the source folder to your build tree and use a C++11 compiler.

Or use your favorite package manager:

Ubuntu: apt-get install libspdlog-dev

Homebrew: brew install spdlog

FreeBSD: cd /usr/ports/devel/spdlog/ && make install clean

Fedora: yum install spdlog

Gentoo: emerge dev-libs/spdlog

Arch Linux: yaourt -S spdlog-git

vcpkg: vcpkg install spdlog

Platforms

Linux, FreeBSD, OpenBSD, Solaris, AIX
Windows (msvc 2013+, cygwin)
macOS (clang 3.5+)
Android

Features

Very fast (see benchmarks below).
Headers only, just copy and use.
Feature rich formatting, using the excellent fmt library.
Fast asynchronous mode (optional)

Custom formatting.
Multi/Single threaded loggers.
Various log targets:

Rotating log files.
Daily log files.
Console logging (colors supported).
syslog.
Windows debugger (OutputDebugString(…))
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.
Binary data logging.

Benchmarks
Below are some benchmarks done in Ubuntu 64 bit, Intel i7-4770 CPU @ 3.40GHz

Synchronous mode

---

Single thread, 1,000,000 iterations

---

basic_st… Elapsed: 0.181652 5,505,042/sec
rotating_st… Elapsed: 0.181781 5,501,117/sec
daily_st… Elapsed: 0.187595 5,330,630/sec
null_st… Elapsed: 0.0504704 19,813,602/sec

---

10 threads sharing same logger, 1,000,000 iterations

---

basic_mt… Elapsed: 0.616035 1,623,284/sec
rotating_mt… Elapsed: 0.620344 1,612,008/sec
daily_mt… Elapsed: 0.648353 1,542,369/sec
null_mt… Elapsed: 0.151972 6,580,166/sec

Asynchronous mode

---

10 threads sharing same logger, 1,000,000 iterations

---

async… Elapsed: 0.350066 2,856,606/sec
async… Elapsed: 0.314865 3,175,960/sec
async… Elapsed: 0.349851 2,858,358/sec

Usage samples
#include “spdlog/spdlog.h”
#include “spdlog/sinks/stdout_color_sinks.h”
void stdout_example()
{
// create color multi threaded logger
auto console = spdlog::stdout_color_mt(“console”);
console->info(“Welcome to spdlog!”);
console->error(“Some error message with arg: {}”, 1);

auto err_logger = spdlog::stderr_color_mt("stderr");
err_logger->error("Some error message");

// 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");

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

// Runtime log levels
spdlog::set_level(spdlog::level::info); // Set global log level to info
console->debug("This message should not be displayed!");
console->set_level(spdlog::level::trace); // Set specific logger's log level
console->debug("This message should be displayed..");

// Customize msg format for all loggers
spdlog::set_pattern("[%H:%M:%S %z] [%n] [%^---%L---%$] [thread %t] %v");
console->info("This an info message with custom format");

// Compile time log levels
// define SPDLOG_DEBUG_ON or 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);

}

Basic file logger
#include “spdlog/sinks/basic_file_sink.h”
void basic_logfile_example()
{
try
{
auto my_logger = spdlog::basic_logger_mt(“basic_logger”, “logs/basic-log.txt”);
}
catch (const spdlog::spdlog_ex &ex)
{
std::cout << "Log init failed: " << ex.what() << std::endl;
}
}

Rotating files
#include “spdlog/sinks/rotating_file_sink.h”
void rotating_example()
{
// Create a file rotating logger with 5mb size max and 3 rotated files
auto rotating_logger = spdlog::rotating_logger_mt(“some_logger_name”, “logs/rotating.txt”, 1048576 * 5, 3);
}

Daily files

#include “spdlog/sinks/daily_file_sink.h”
void daily_example()
{
// Create a daily logger - a new file is created every day on 2:30am
auto daily_logger = spdlog::daily_logger_mt(“daily_logger”, “logs/daily.txt”, 2, 30);
}

Cloning loggers
// clone a logger and give it new name.
// Useful for creating subsystem loggers from some “root” logger
void clone_example()
{
auto network_logger = spdlog::get(“root”)->clone(“network”);
network_logger->info(“Logging network stuff…”);
}

Periodic flush
// periodically flush all registered loggers every 3 seconds:
// warning: only use if all your loggers are thread safe!
spdlog::flush_every(std::chrono::seconds(3));

Binary logging
// log binary data as hex.
// many types of std::container types can be used.
// ranges are supported too.
// format flags:
// {:X} - print in uppercase.
// {????} - don’t separate each byte with space.
// {:p} - don’t print the position on each line start.
// {:n} - don’t split the output to lines.

#include “spdlog/fmt/bin_to_hex.h”

void binary_example()
{
auto console = spdlog::get(“console”);
std::array<char, 80> buf;
console->info(“Binary example: {}”, spdlog::to_hex(buf));
console->info(“Another binary example:{:n}”, spdlog::to_hex(std::begin(buf), std::begin(buf) + 10));
// more examples:
// logger->info(“uppercase: {:X}”, spdlog::to_hex(buf));
// logger->info(“uppercase, no delimiters: {:Xs}”, spdlog::to_hex(buf));
// logger->info(“uppercase, no delimiters, no position info: {:Xsp}”, spdlog::to_hex(buf));
}

Logger with multi sinks - each with different format and log level

// create logger with 2 targets with different log levels and formats.
// the console will show only warnings or errors, while the file will log all.
void multi_sink_example()
{
auto console_sink = std::make_sharedspdlog::sinks::stdout_color_sink_mt();
console_sink->set_level(spdlog::level::warn);
console_sink->set_pattern("[multi_sink_example] [%^%l%$] %v");

auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("logs/multisink.txt", true);
file_sink->set_level(spdlog::level::trace);

spdlog::logger logger("multi_sink", {console_sink, file_sink});
logger.set_level(spdlog::level::debug);
logger.warn("this should appear in both console and file");
logger.info("this message should not appear in the console, only in the file");

}

Asynchronous logging
#include “spdlog/async.h”
#include “spdlog/sinks/basic_file_sink.h”
void async_example()
{
// default thread pool settings can be modified before creating the async logger:
// spdlog::init_thread_pool(8192, 1); // queue with 8k items and 1 backing thread.
auto async_file = spdlog::basic_logger_mtspdlog::async_factory(“async_file_logger”, “logs/async_log.txt”);
// alternatively:
// auto async_file = spdlog::create_asyncspdlog::sinks::basic_file_sink_mt(“async_file_logger”, “logs/async_log.txt”);
}

Asynchronous logger with multi sinks
#include “spdlog/sinks/stdout_color_sinks.h”
#include “spdlog/sinks/rotating_file_sink.h”

void multi_sink_example2()
{
spdlog::init_thread_pool(8192, 1);
auto stdout_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt >();
auto rotating_sink = std::make_sharedspdlog::sinks::rotating_file_sink_mt(“mylog.txt”, 1024102410, 3);
std::vectorspdlog::sink_ptr sinks {stdout_sink, rotating_sink};
auto logger = std::make_sharedspdlog::async_logger(“loggername”, sinks.begin(), sinks.end(), spdlog::thread_pool(), spdlog::async_overflow_policy::block);
spdlog::register_logger(logger);
}

User defined types
// user defined types logging by implementing operator<<
#include “spdlog/fmt/ostr.h” // must be included
struct my_type
{
int i;
template
friend OStream &operator<<(OStream &os, const my_type &c)
{
return os << “[my_type i=” << c.i << “]”;
}
};

void user_defined_example()
{
spdlog::get(“console”)->info(“user defined type: {}”, my_type{14});
}

Custom error handler
void err_handler_example()
{
// can be set globally or per logger(logger->set_error_handler(…))
spdlog::set_error_handler([](const std::string &msg) { spdlog::get(“console”)->error("*** LOGGER ERROR ***: {}", msg); });
spdlog::get(“console”)->info(“some invalid message to trigger an error {}{}{}{}”, 3);
}

syslog
#include “spdlog/sinks/syslog_sink.h”
void syslog_example()
{
std::string ident = “spdlog-example”;
auto syslog_logger = spdlog::syslog_logger_mt(“syslog”, ident, LOG_PID);
syslog_logger->warn(“This is warning that will end up in syslog.”);
}

Android example
#include “spdlog/sinks/android_sink.h”
void android_example()
{
std::string tag = “spdlog-android”;
auto android_logger = spdlog::android_logger(“android”, tag);
android_logger->critical(“Use “adb shell logcat” to view this message.”);
}

Documentation
Documentation can be found in the wiki pages.