mirror of
https://github.com/gabime/spdlog.git
synced 2024-12-25 01:51:38 +08:00
commit
d073b97b88
26
README.md
26
README.md
@ -5,18 +5,16 @@ Very fast, header only, C++ logging library.
|
||||
## Install
|
||||
Just copy the files to your build tree and use a C++11 compiler
|
||||
|
||||
## Tested on:
|
||||
* gcc 4.8.1 and above
|
||||
* clang 3.5
|
||||
* visual studio 2013
|
||||
* mingw with g++ 4.9.x
|
||||
|
||||
## Platforms
|
||||
* Linux (gcc 4.8.1+, clang 3.5+)
|
||||
* Windows (visual studio 2013+, mingw with g++ 4.9.1+)
|
||||
* Mac OSX (clang 3.5+)
|
||||
|
||||
##Features
|
||||
* Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below).
|
||||
* Headers only.
|
||||
* No dependencies - just copy and use.
|
||||
* Cross platform - Linux / Windows on 32/64 bits.
|
||||
* **new!** Feature rich [call style](#usage-example) using the excellent [cppformat](http://cppformat.github.io/) library.
|
||||
* Feature rich [call style](#usage-example) using the excellent [cppformat](http://cppformat.github.io/) 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](https://github.com/gabime/spdlog/wiki/Custom-formatting) formatting.
|
||||
@ -73,7 +71,7 @@ int main(int, char* [])
|
||||
console->info("An info message example {}..", 1);
|
||||
console->info() << "Streams are supported too " << 1;
|
||||
|
||||
//Formatting examples
|
||||
//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);
|
||||
@ -98,6 +96,11 @@ int main(int, char* [])
|
||||
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
|
||||
//
|
||||
@ -148,5 +151,8 @@ void custom_class_example()
|
||||
spdlog::get("console")->info("custom class with operator<<: {}..", c);
|
||||
spdlog::get("console")->info() << "custom class with operator<<: " << c << "..";
|
||||
}
|
||||
|
||||
```
|
||||
|
||||
## Documentation
|
||||
Documentation can be found in the [wiki](https://github.com/gabime/spdlog/wiki/1.-QuickStart) pages.
|
||||
|
||||
|
@ -1,235 +0,0 @@
|
||||
----------------------------------------------------------
|
||||
Single threaded benchmarks.. (1 thread, 1,000,000 lines)
|
||||
----------------------------------------------------------
|
||||
**************** boost-bench ****************
|
||||
|
||||
real 0m4.382s
|
||||
user 0m4.213s
|
||||
sys 0m0.048s
|
||||
|
||||
real 0m4.159s
|
||||
user 0m4.120s
|
||||
sys 0m0.040s
|
||||
|
||||
real 0m4.169s
|
||||
user 0m4.117s
|
||||
sys 0m0.052s
|
||||
**************** glog-bench ****************
|
||||
|
||||
real 0m1.082s
|
||||
user 0m0.944s
|
||||
sys 0m0.136s
|
||||
|
||||
real 0m1.079s
|
||||
user 0m0.977s
|
||||
sys 0m0.101s
|
||||
|
||||
real 0m1.066s
|
||||
user 0m0.951s
|
||||
sys 0m0.114s
|
||||
**************** easylogging-bench ****************
|
||||
|
||||
real 0m0.975s
|
||||
user 0m0.963s
|
||||
sys 0m0.012s
|
||||
|
||||
real 0m0.986s
|
||||
user 0m0.954s
|
||||
sys 0m0.033s
|
||||
|
||||
real 0m0.963s
|
||||
user 0m0.919s
|
||||
sys 0m0.044s
|
||||
**************** spdlog-bench ****************
|
||||
|
||||
real 0m0.302s
|
||||
user 0m0.285s
|
||||
sys 0m0.016s
|
||||
|
||||
real 0m0.311s
|
||||
user 0m0.287s
|
||||
sys 0m0.025s
|
||||
|
||||
real 0m0.308s
|
||||
user 0m0.276s
|
||||
sys 0m0.032s
|
||||
----------------------------------------------------------
|
||||
Multi threaded benchmarks.. (10 threads, 1,000,000 lines)
|
||||
----------------------------------------------------------
|
||||
**************** boost-bench-mt ****************
|
||||
|
||||
real 0m16.293s
|
||||
user 0m38.723s
|
||||
sys 0m8.469s
|
||||
|
||||
real 0m16.029s
|
||||
user 0m39.186s
|
||||
sys 0m8.413s
|
||||
|
||||
real 0m16.257s
|
||||
user 0m38.322s
|
||||
sys 0m7.880s
|
||||
**************** glog-bench-mt ****************
|
||||
|
||||
real 0m4.455s
|
||||
user 0m12.871s
|
||||
sys 0m13.508s
|
||||
|
||||
real 0m5.039s
|
||||
user 0m14.239s
|
||||
sys 0m15.900s
|
||||
|
||||
real 0m3.032s
|
||||
user 0m8.654s
|
||||
sys 0m9.473s
|
||||
**************** easylogging-bench-mt ****************
|
||||
|
||||
real 0m4.076s
|
||||
user 0m4.350s
|
||||
sys 0m2.861s
|
||||
|
||||
real 0m2.857s
|
||||
user 0m3.270s
|
||||
sys 0m1.744s
|
||||
|
||||
real 0m4.588s
|
||||
user 0m5.085s
|
||||
sys 0m3.058s
|
||||
**************** spdlog-bench-mt ****************
|
||||
|
||||
real 0m2.374s
|
||||
user 0m4.369s
|
||||
sys 0m10.426s
|
||||
|
||||
real 0m0.968s
|
||||
user 0m1.804s
|
||||
sys 0m4.186s
|
||||
|
||||
real 0m1.527s
|
||||
user 0m3.132s
|
||||
sys 0m6.427s
|
||||
----------------------------------------------------------
|
||||
Multi threaded benchmarks.. (100 threads, 1,000,000 lines)
|
||||
----------------------------------------------------------
|
||||
**************** boost-bench-mt ****************
|
||||
|
||||
real 0m15.623s
|
||||
user 0m39.283s
|
||||
sys 0m8.428s
|
||||
|
||||
real 0m15.008s
|
||||
user 0m36.851s
|
||||
sys 0m7.956s
|
||||
|
||||
real 0m15.478s
|
||||
user 0m38.873s
|
||||
sys 0m8.368s
|
||||
**************** glog-bench-mt ****************
|
||||
|
||||
real 0m1.139s
|
||||
user 0m3.003s
|
||||
sys 0m5.214s
|
||||
|
||||
real 0m1.167s
|
||||
user 0m3.004s
|
||||
sys 0m5.431s
|
||||
|
||||
real 0m1.159s
|
||||
user 0m2.909s
|
||||
sys 0m5.456s
|
||||
**************** easylogging-bench-mt ****************
|
||||
|
||||
real 0m4.510s
|
||||
user 0m4.565s
|
||||
sys 0m3.510s
|
||||
|
||||
real 0m8.841s
|
||||
user 0m8.363s
|
||||
sys 0m7.057s
|
||||
|
||||
real 0m5.638s
|
||||
user 0m5.531s
|
||||
sys 0m4.168s
|
||||
**************** spdlog-bench-mt ****************
|
||||
|
||||
real 0m0.497s
|
||||
user 0m0.951s
|
||||
sys 0m2.743s
|
||||
|
||||
real 0m0.502s
|
||||
user 0m0.940s
|
||||
sys 0m2.816s
|
||||
|
||||
real 0m0.504s
|
||||
user 0m0.911s
|
||||
sys 0m2.860s
|
||||
---------------------------------------------------------------
|
||||
Async, single threaded benchmark.. (1 thread, 1,000,000 lines)
|
||||
---------------------------------------------------------------
|
||||
**************** spdlog-async ****************
|
||||
Total: 1000000
|
||||
Threads: 1
|
||||
Delta = 0.216366 seconds
|
||||
Rate = 4.62179e+06/sec
|
||||
Total: 1000000
|
||||
Threads: 1
|
||||
Delta = 0.215076 seconds
|
||||
Rate = 4.64953e+06/sec
|
||||
Total: 1000000
|
||||
Threads: 1
|
||||
Delta = 0.210712 seconds
|
||||
Rate = 4.74581e+06/sec
|
||||
**************** g2log-async ****************
|
||||
Total: 1000000
|
||||
Threads: 1
|
||||
Delta = 1.85039 seconds
|
||||
Rate = 540428/sec
|
||||
|
||||
Exiting, log location: logs/g2log-async.g2log.20141220-214929.log
|
||||
Total: 1000000
|
||||
Threads: 1
|
||||
Delta = 1.85434 seconds
|
||||
Rate = 539274/sec
|
||||
|
||||
Exiting, log location: logs/g2log-async.g2log.20141220-214935.log
|
||||
Total: 1000000
|
||||
Threads: 1
|
||||
Delta = 1.86829 seconds
|
||||
Rate = 535249/sec
|
||||
|
||||
Exiting, log location: logs/g2log-async.g2log.20141220-214941.log
|
||||
---------------------------------------------------------------
|
||||
Async, multi threaded benchmark.. (10 threads, 1,000,000 lines)
|
||||
---------------------------------------------------------------
|
||||
**************** spdlog-async ****************
|
||||
Total: 1000000
|
||||
Threads: 10
|
||||
Delta = 0.175684 seconds
|
||||
Rate = 5.69204e+06/sec
|
||||
Total: 1000000
|
||||
Threads: 10
|
||||
Delta = 0.173104 seconds
|
||||
Rate = 5.77688e+06/sec
|
||||
Total: 1000000
|
||||
Threads: 10
|
||||
Delta = 0.173881 seconds
|
||||
Rate = 5.75106e+06/sec
|
||||
**************** g2log-async ****************
|
||||
Total: 1000000
|
||||
Threads: 10
|
||||
Delta = 0.945252 seconds
|
||||
Rate = 1.05792e+06/sec
|
||||
|
||||
Exiting, log location: logs/g2log-async.g2log.20141220-214958.log
|
||||
Total: 1000000
|
||||
Threads: 10
|
||||
Delta = 0.950362 seconds
|
||||
Rate = 1.05223e+06/sec
|
||||
|
||||
Exiting, log location: logs/g2log-async.g2log.20141220-215004.log
|
||||
Total: 1000000
|
||||
Threads: 10
|
||||
Delta = 0.943302 seconds
|
||||
Rate = 1.06011e+06/sec
|
||||
|
||||
Exiting, log location: logs/g2log-async.g2log.20141220-215011.log
|
@ -50,7 +50,8 @@ void bench_mt(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count
|
||||
int main(int argc, char* argv[])
|
||||
{
|
||||
|
||||
int howmany = 1048576;
|
||||
int queue_size = 1048576;
|
||||
int howmany = 1000000;
|
||||
int threads = 10;
|
||||
bool auto_flush = false;
|
||||
int file_size = 30 * 1024 * 1024;
|
||||
@ -63,6 +64,8 @@ int main(int argc, char* argv[])
|
||||
howmany = atoi(argv[1]);
|
||||
if (argc > 2)
|
||||
threads = atoi(argv[2]);
|
||||
if (argc > 3)
|
||||
queue_size = atoi(argv[3]);
|
||||
|
||||
|
||||
cout << "*******************************************************************************\n";
|
||||
@ -92,7 +95,7 @@ int main(int argc, char* argv[])
|
||||
cout << "*******************************************************************************\n";
|
||||
|
||||
|
||||
spdlog::set_async_mode(howmany);
|
||||
spdlog::set_async_mode(queue_size);
|
||||
|
||||
for(int i = 0; i < 3; ++i)
|
||||
{
|
||||
|
@ -28,20 +28,18 @@
|
||||
#include <iostream>
|
||||
#include "spdlog/spdlog.h"
|
||||
|
||||
int main(int, char* [])
|
||||
int main(int, char*[])
|
||||
{
|
||||
namespace spd = spdlog;
|
||||
try
|
||||
{
|
||||
// Set log level to all loggers to debug and above
|
||||
spd::set_level(spd::level::debug);
|
||||
|
||||
// Create console, multithreaded logger
|
||||
auto console = spd::stdout_logger_mt("console");
|
||||
console->info("Hello {}", 1);
|
||||
//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;
|
||||
|
||||
//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);
|
||||
@ -51,37 +49,59 @@ int main(int, char* [])
|
||||
console->info("{:>30}", "right aligned");
|
||||
console->info("{:^30}", "centered");
|
||||
|
||||
//
|
||||
// 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..");
|
||||
|
||||
//
|
||||
// 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);
|
||||
file_logger->set_level(spd::level::info);
|
||||
for(int i = 0; i < 10; ++i)
|
||||
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");
|
||||
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!";
|
||||
|
||||
spdlog::drop_all(); //Close all loggers
|
||||
//
|
||||
// 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
|
||||
|
||||
//Close all loggers
|
||||
spd::drop_all();
|
||||
}
|
||||
catch (const spd::spdlog_ex& ex)
|
||||
{
|
||||
@ -90,16 +110,17 @@ int main(int, char* [])
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// Example of user defined class with operator<<
|
||||
//
|
||||
class some_class {};
|
||||
std::ostream& operator<<(std::ostream& os, const some_class&) { return os << "some_class"; }
|
||||
std::ostream& operator<<(std::ostream& os, const some_class&)
|
||||
{
|
||||
return os << "some_class";
|
||||
}
|
||||
|
||||
void custom_class_example()
|
||||
{
|
||||
some_class c;
|
||||
spdlog::get("console")->info("custom class with operator<<: {}", c);
|
||||
spdlog::get("console")->info() << "custom class with operator<<: " << c;
|
||||
spdlog::get("console")->info("custom class with operator<<: {}..", c);
|
||||
spdlog::get("console")->info() << "custom class with operator<<: " << c << "..";
|
||||
}
|
||||
|
||||
|
@ -33,16 +33,9 @@
|
||||
#ifndef _MSC_VER
|
||||
#define SPDLOG_NOEXCEPT noexcept
|
||||
#else
|
||||
#define SPDLOG_NOEXCEPT
|
||||
#define SPDLOG_NOEXCEPT throw()
|
||||
#endif
|
||||
|
||||
// under linux, you can use the much faster CLOCK_REALTIME_COARSE clock.
|
||||
// this clock is less accurate - can be off by few millis - depending on the kernel HZ
|
||||
// uncomment to use it instead of the regular (and slower) clock
|
||||
|
||||
//#ifdef __linux__
|
||||
//#define SPDLOG_CLOCK_COARSE
|
||||
//#endif
|
||||
|
||||
namespace spdlog
|
||||
{
|
||||
@ -60,6 +53,7 @@ using sink_ptr = std::shared_ptr < sinks::sink > ;
|
||||
using sinks_init_list = std::initializer_list < sink_ptr > ;
|
||||
using formatter_ptr = std::shared_ptr<spdlog::formatter>;
|
||||
|
||||
|
||||
//Log level enum
|
||||
namespace level
|
||||
{
|
||||
|
@ -59,44 +59,50 @@ class async_log_helper
|
||||
std::string logger_name;
|
||||
level::level_enum level;
|
||||
log_clock::time_point time;
|
||||
size_t thread_id;
|
||||
std::string txt;
|
||||
|
||||
async_msg() = default;
|
||||
~async_msg() = default;
|
||||
|
||||
async_msg(const async_msg&) = delete;
|
||||
async_msg& operator=(async_msg& other) = delete;
|
||||
|
||||
async_msg(const details::log_msg& m) :
|
||||
logger_name(m.logger_name),
|
||||
level(m.level),
|
||||
time(m.time),
|
||||
txt(m.raw.data(), m.raw.size())
|
||||
async_msg(async_msg&& other) SPDLOG_NOEXCEPT:
|
||||
logger_name(std::move(other.logger_name)),
|
||||
level(std::move(other.level)),
|
||||
time(std::move(other.time)),
|
||||
txt(std::move(other.txt))
|
||||
{}
|
||||
|
||||
async_msg(async_msg&& other) :
|
||||
logger_name(std::move(other.logger_name)),
|
||||
level(std::move(other.level)),
|
||||
time(std::move(other.time)),
|
||||
txt(std::move(other.txt))
|
||||
{}
|
||||
|
||||
async_msg& operator=(async_msg&& other)
|
||||
async_msg& operator=(async_msg&& other) SPDLOG_NOEXCEPT
|
||||
{
|
||||
logger_name = std::move(other.logger_name);
|
||||
level = other.level;
|
||||
time = std::move(other.time);
|
||||
thread_id = other.thread_id;
|
||||
txt = std::move(other.txt);
|
||||
return *this;
|
||||
}
|
||||
// never copy or assign. should only be moved..
|
||||
async_msg(const async_msg&) = delete;
|
||||
async_msg& operator=(async_msg& other) = delete;
|
||||
|
||||
// construct from log_msg
|
||||
async_msg(const details::log_msg& m) :
|
||||
logger_name(m.logger_name),
|
||||
level(m.level),
|
||||
time(m.time),
|
||||
thread_id(m.thread_id),
|
||||
txt(m.raw.data(), m.raw.size())
|
||||
{}
|
||||
|
||||
|
||||
// copy into log_msg
|
||||
void fill_log_msg(log_msg &msg)
|
||||
{
|
||||
msg.clear();
|
||||
msg.logger_name = logger_name;
|
||||
msg.level = level;
|
||||
msg.time = time;
|
||||
msg.thread_id = thread_id;
|
||||
msg.raw << txt;
|
||||
}
|
||||
};
|
||||
@ -117,8 +123,9 @@ public:
|
||||
|
||||
void log(const details::log_msg& msg);
|
||||
|
||||
//Stop logging and join the back thread
|
||||
// stop logging and join the back thread
|
||||
~async_log_helper();
|
||||
|
||||
void set_formatter(formatter_ptr);
|
||||
|
||||
|
||||
@ -147,11 +154,11 @@ private:
|
||||
// worker thread main loop
|
||||
void worker_loop();
|
||||
|
||||
//pop next message from the queue and process it
|
||||
//return true if a message was available (queue was not empty), will set the last_pop to the pop time
|
||||
// pop next message from the queue and process it
|
||||
// return true if a message was available (queue was not empty), will set the last_pop to the pop time
|
||||
bool process_next_msg(clock::time_point& last_pop);
|
||||
|
||||
// guess how much to sleep if queue is empty/full using last successful op time as hint
|
||||
// sleep,yield or return immediatly using the time passed since last message as a hint
|
||||
static void sleep_or_yield(const clock::time_point& last_op_time);
|
||||
|
||||
};
|
||||
@ -220,8 +227,8 @@ inline void spdlog::details::async_log_helper::worker_loop()
|
||||
}
|
||||
}
|
||||
|
||||
// Process next message in the queue
|
||||
// Return true if this thread should still be active (no msg with level::off was received)
|
||||
// process next message in the queue
|
||||
// return true if this thread should still be active (no msg with level::off was received)
|
||||
inline bool spdlog::details::async_log_helper::process_next_msg(clock::time_point& last_pop)
|
||||
{
|
||||
|
||||
@ -253,7 +260,7 @@ inline void spdlog::details::async_log_helper::set_formatter(formatter_ptr msg_f
|
||||
}
|
||||
|
||||
|
||||
// Sleep,yield or return immediatly using the time passed since last message as a hint
|
||||
// sleep,yield or return immediatly using the time passed since last message as a hint
|
||||
inline void spdlog::details::async_log_helper::sleep_or_yield(const clock::time_point& last_op_time)
|
||||
{
|
||||
using std::chrono::milliseconds;
|
||||
@ -261,7 +268,7 @@ inline void spdlog::details::async_log_helper::sleep_or_yield(const clock::time_
|
||||
|
||||
auto time_since_op = clock::now() - last_op_time;
|
||||
|
||||
//spin upto 1 ms
|
||||
// spin upto 1 ms
|
||||
if (time_since_op <= milliseconds(1))
|
||||
return;
|
||||
|
||||
@ -277,7 +284,7 @@ inline void spdlog::details::async_log_helper::sleep_or_yield(const clock::time_
|
||||
return sleep_for(milliseconds(100));
|
||||
}
|
||||
|
||||
//throw if the worker thread threw an exception or not active
|
||||
// throw if the worker thread threw an exception or not active
|
||||
inline void spdlog::details::async_log_helper::throw_if_bad_worker()
|
||||
{
|
||||
if (_last_workerthread_ex)
|
||||
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -27,7 +27,6 @@
|
||||
#include "../common.h"
|
||||
#include "../logger.h"
|
||||
|
||||
|
||||
// Line logger class - aggregates operator<< calls to fast ostream
|
||||
// and logs upon destruction
|
||||
|
||||
@ -63,8 +62,16 @@ public:
|
||||
{
|
||||
if (_enabled)
|
||||
{
|
||||
#ifndef SPDLOG_NO_NAME
|
||||
_log_msg.logger_name = _callback_logger->name();
|
||||
#endif
|
||||
#ifndef SPDLOG_NO_DATETIME
|
||||
_log_msg.time = os::now();
|
||||
#endif
|
||||
|
||||
#ifndef SPDLOG_NO_THREAD_ID
|
||||
_log_msg.thread_id = os::thread_id();
|
||||
#endif
|
||||
_callback_logger->_log_msg(_log_msg);
|
||||
}
|
||||
}
|
||||
|
@ -24,6 +24,7 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <thread>
|
||||
#include "../common.h"
|
||||
#include "./format.h"
|
||||
|
||||
@ -37,7 +38,6 @@ struct log_msg
|
||||
log_msg(level::level_enum l):
|
||||
logger_name(),
|
||||
level(l),
|
||||
time(),
|
||||
raw(),
|
||||
formatted() {}
|
||||
|
||||
@ -45,7 +45,8 @@ struct log_msg
|
||||
log_msg(const log_msg& other) :
|
||||
logger_name(other.logger_name),
|
||||
level(other.level),
|
||||
time(other.time)
|
||||
time(other.time),
|
||||
thread_id(other.thread_id)
|
||||
{
|
||||
if (other.raw.size())
|
||||
raw << fmt::BasicStringRef<char>(other.raw.data(), other.raw.size());
|
||||
@ -57,6 +58,7 @@ struct log_msg
|
||||
logger_name(std::move(other.logger_name)),
|
||||
level(other.level),
|
||||
time(std::move(other.time)),
|
||||
thread_id(other.thread_id),
|
||||
raw(std::move(other.raw)),
|
||||
formatted(std::move(other.formatted))
|
||||
{
|
||||
@ -71,6 +73,7 @@ struct log_msg
|
||||
logger_name = std::move(other.logger_name);
|
||||
level = other.level;
|
||||
time = std::move(other.time);
|
||||
thread_id = other.thread_id;
|
||||
raw = std::move(other.raw);
|
||||
formatted = std::move(other.formatted);
|
||||
other.clear();
|
||||
@ -87,6 +90,7 @@ struct log_msg
|
||||
std::string logger_name;
|
||||
level::level_enum level;
|
||||
log_clock::time_point time;
|
||||
size_t thread_id;
|
||||
fmt::MemoryWriter raw;
|
||||
fmt::MemoryWriter formatted;
|
||||
};
|
||||
|
@ -32,6 +32,16 @@
|
||||
# define WIN32_LEAN_AND_MEAN
|
||||
# endif
|
||||
# include <Windows.h>
|
||||
|
||||
#ifdef __MINGW32__
|
||||
#include <share.h>
|
||||
#endif
|
||||
|
||||
#elif __linux__
|
||||
#include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
|
||||
#include <unistd.h>
|
||||
#else
|
||||
#include <thread>
|
||||
#endif
|
||||
|
||||
#include "../common.h"
|
||||
@ -46,7 +56,7 @@ namespace os
|
||||
inline spdlog::log_clock::time_point now()
|
||||
{
|
||||
|
||||
#ifdef SPDLOG_CLOCK_COARSE
|
||||
#if defined __linux__ && defined SPDLOG_CLOCK_COARSE
|
||||
timespec ts;
|
||||
::clock_gettime(CLOCK_REALTIME_COARSE, &ts);
|
||||
return std::chrono::time_point<log_clock, typename log_clock::duration>(
|
||||
@ -73,7 +83,7 @@ inline std::tm localtime(const std::time_t &time_tt)
|
||||
|
||||
inline std::tm localtime()
|
||||
{
|
||||
std::time_t now_t = time(0);
|
||||
std::time_t now_t = time(nullptr);
|
||||
return localtime(now_t);
|
||||
}
|
||||
|
||||
@ -93,7 +103,7 @@ inline std::tm gmtime(const std::time_t &time_tt)
|
||||
|
||||
inline std::tm gmtime()
|
||||
{
|
||||
std::time_t now_t = time(0);
|
||||
std::time_t now_t = time(nullptr);
|
||||
return gmtime(now_t);
|
||||
}
|
||||
inline bool operator==(const std::tm& tm1, const std::tm& tm2)
|
||||
@ -166,6 +176,19 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
|
||||
#endif
|
||||
}
|
||||
|
||||
//Return current thread id as size_t
|
||||
//It exists because the std::this_thread::get_id() is much slower(espcially under VS 2013)
|
||||
inline size_t thread_id()
|
||||
{
|
||||
#ifdef _WIN32
|
||||
return static_cast<size_t>(::GetCurrentThreadId());
|
||||
#elif __linux__
|
||||
return static_cast<size_t>(syscall(SYS_gettid));
|
||||
#else //Default to standard C++11 (OSX and other Unix)
|
||||
return static_cast<size_t>(std::hash<std::thread::id>()(std::this_thread::get_id()));
|
||||
#endif
|
||||
|
||||
}
|
||||
|
||||
} //os
|
||||
} //details
|
||||
|
@ -354,7 +354,7 @@ class t_formatter :public flag_formatter
|
||||
{
|
||||
void format(details::log_msg& msg, const std::tm&) override
|
||||
{
|
||||
msg.formatted << std::hash<std::thread::id>()(std::this_thread::get_id());
|
||||
msg.formatted << msg.thread_id;
|
||||
}
|
||||
};
|
||||
|
||||
@ -405,6 +405,7 @@ class full_formatter :public flag_formatter
|
||||
{
|
||||
void format(details::log_msg& msg, const std::tm& tm_time) override
|
||||
{
|
||||
#ifndef SPDLOG_NO_DATETIME
|
||||
auto duration = msg.time.time_since_epoch();
|
||||
auto millis = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() % 1000;
|
||||
|
||||
@ -421,6 +422,7 @@ class full_formatter :public flag_formatter
|
||||
level::to_str(msg.level),
|
||||
msg.raw.str());*/
|
||||
|
||||
|
||||
// Faster (albeit uglier) way to format the line (5.6 million lines/sec under 10 threads)
|
||||
msg.formatted << '[' << static_cast<unsigned int>(tm_time.tm_year + 1900) << '-'
|
||||
<< fmt::pad(static_cast<unsigned int>(tm_time.tm_mon + 1), 2, '0') << '-'
|
||||
@ -430,7 +432,16 @@ class full_formatter :public flag_formatter
|
||||
<< fmt::pad(static_cast<unsigned int>(tm_time.tm_sec), 2, '0') << '.'
|
||||
<< fmt::pad(static_cast<unsigned int>(millis), 3, '0') << "] ";
|
||||
|
||||
msg.formatted << '[' << msg.logger_name << "] [" << level::to_str(msg.level) << "] ";
|
||||
//no datetime needed
|
||||
#else
|
||||
(void)tm_time;
|
||||
#endif
|
||||
|
||||
#ifndef SPDLOG_NO_NAME
|
||||
msg.formatted << '[' << msg.logger_name << "] ";
|
||||
#endif
|
||||
|
||||
msg.formatted << '[' << level::to_str(msg.level) << "] ";
|
||||
msg.formatted << fmt::StringRef(msg.raw.data(), msg.raw.size());
|
||||
}
|
||||
};
|
||||
@ -478,7 +489,7 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
|
||||
{
|
||||
switch (flag)
|
||||
{
|
||||
// logger name
|
||||
// logger name
|
||||
case 'n':
|
||||
_formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::name_formatter()));
|
||||
break;
|
||||
@ -490,7 +501,7 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
|
||||
case 'L':
|
||||
_formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::short_level_formatter()));
|
||||
break;
|
||||
|
||||
|
||||
case('t') :
|
||||
_formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::t_formatter()));
|
||||
break;
|
||||
@ -610,8 +621,8 @@ inline void spdlog::pattern_formatter::format(details::log_msg& msg)
|
||||
//write eol
|
||||
msg.formatted << details::os::eol();
|
||||
}
|
||||
catch(const details::fmt::FormatError& e)
|
||||
catch(const fmt::FormatError& e)
|
||||
{
|
||||
throw spdlog_ex(details::fmt::format("formatting error while processing format string: {}", e.what()));
|
||||
throw spdlog_ex(fmt::format("formatting error while processing format string: {}", e.what()));
|
||||
}
|
||||
}
|
||||
|
@ -41,10 +41,17 @@ namespace spdlog
|
||||
{
|
||||
namespace details
|
||||
{
|
||||
|
||||
class registry
|
||||
{
|
||||
public:
|
||||
|
||||
void register_logger(std::shared_ptr<logger> logger)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(_mutex);
|
||||
register_logger_impl(logger);
|
||||
}
|
||||
|
||||
|
||||
std::shared_ptr<logger> get(const std::string& logger_name)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(_mutex);
|
||||
@ -55,12 +62,12 @@ public:
|
||||
template<class It>
|
||||
std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(_mutex);
|
||||
//If already exists, just return it
|
||||
auto found = _loggers.find(logger_name);
|
||||
if (found != _loggers.end())
|
||||
return found->second;
|
||||
|
||||
std::shared_ptr<logger> new_logger;
|
||||
|
||||
std::lock_guard<std::mutex> lock(_mutex);
|
||||
|
||||
|
||||
if (_async_mode)
|
||||
new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy, _worker_warmup_cb);
|
||||
else
|
||||
@ -68,8 +75,9 @@ public:
|
||||
|
||||
if (_formatter)
|
||||
new_logger->set_formatter(_formatter);
|
||||
|
||||
new_logger->set_level(_level);
|
||||
_loggers[logger_name] = new_logger;
|
||||
register_logger_impl(new_logger);
|
||||
return new_logger;
|
||||
}
|
||||
|
||||
@ -103,14 +111,12 @@ public:
|
||||
l.second->set_formatter(_formatter);
|
||||
}
|
||||
|
||||
|
||||
void set_pattern(const std::string& pattern)
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(_mutex);
|
||||
_formatter = std::make_shared<pattern_formatter>(pattern);
|
||||
for (auto& l : _loggers)
|
||||
l.second->set_formatter(_formatter);
|
||||
|
||||
}
|
||||
|
||||
void set_level(level::level_enum log_level)
|
||||
@ -118,6 +124,7 @@ public:
|
||||
std::lock_guard<std::mutex> lock(_mutex);
|
||||
for (auto& l : _loggers)
|
||||
l.second->set_level(log_level);
|
||||
_level = log_level;
|
||||
}
|
||||
|
||||
void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb)
|
||||
@ -135,7 +142,6 @@ public:
|
||||
_async_mode = false;
|
||||
}
|
||||
|
||||
|
||||
static registry& instance()
|
||||
{
|
||||
static registry s_instance;
|
||||
@ -143,6 +149,13 @@ public:
|
||||
}
|
||||
|
||||
private:
|
||||
void register_logger_impl(std::shared_ptr<logger> logger)
|
||||
{
|
||||
auto logger_name = logger->name();
|
||||
if (_loggers.find(logger_name) != std::end(_loggers))
|
||||
throw spdlog_ex("logger with name " + logger_name + " already exists");
|
||||
_loggers[logger->name()] = logger;
|
||||
}
|
||||
registry() = default;
|
||||
registry(const registry&) = delete;
|
||||
registry& operator=(const registry&) = delete;
|
||||
|
@ -32,6 +32,11 @@
|
||||
#include "../sinks/stdout_sinks.h"
|
||||
#include "../sinks/syslog_sink.h"
|
||||
|
||||
inline void spdlog::register_logger(std::shared_ptr<logger> logger)
|
||||
{
|
||||
return details::registry::instance().register_logger(logger);
|
||||
}
|
||||
|
||||
inline std::shared_ptr<spdlog::logger> spdlog::get(const std::string& name)
|
||||
{
|
||||
return details::registry::instance().get(name);
|
||||
@ -54,35 +59,35 @@ inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::str
|
||||
}
|
||||
|
||||
// Create file logger which creates new file at midnight):
|
||||
inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const std::string& filename, bool force_flush)
|
||||
inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush)
|
||||
{
|
||||
return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, "txt", force_flush);
|
||||
return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, "txt", hour, minute, force_flush);
|
||||
}
|
||||
inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const std::string& filename, bool force_flush)
|
||||
inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const std::string& filename, int hour, int minute, bool force_flush)
|
||||
{
|
||||
return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, "txt", force_flush);
|
||||
return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, "txt", hour, minute, force_flush);
|
||||
}
|
||||
|
||||
|
||||
// Create stdout/stderr loggers
|
||||
inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_mt(const std::string& logger_name)
|
||||
{
|
||||
return create<spdlog::sinks::stdout_sink_mt>(logger_name);
|
||||
return details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_mt::instance());
|
||||
}
|
||||
|
||||
inline std::shared_ptr<spdlog::logger> spdlog::stdout_logger_st(const std::string& logger_name)
|
||||
{
|
||||
return create<spdlog::sinks::stdout_sink_st>(logger_name);
|
||||
return details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_st::instance());
|
||||
}
|
||||
|
||||
inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_mt(const std::string& logger_name)
|
||||
{
|
||||
return create<spdlog::sinks::stderr_sink_mt>(logger_name);
|
||||
return details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_mt::instance());
|
||||
}
|
||||
|
||||
inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st(const std::string& logger_name)
|
||||
{
|
||||
return create<spdlog::sinks::stderr_sink_st>(logger_name);
|
||||
return details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_st::instance());
|
||||
}
|
||||
|
||||
#ifdef __linux__
|
||||
|
@ -30,21 +30,19 @@
|
||||
#include "../details/file_helper.h"
|
||||
#include "../details/format.h"
|
||||
|
||||
|
||||
namespace spdlog
|
||||
{
|
||||
namespace sinks
|
||||
{
|
||||
|
||||
/*
|
||||
* Trivial file sink with single file as target
|
||||
*/
|
||||
template<class Mutex>
|
||||
class simple_file_sink : public base_sink<Mutex>
|
||||
class simple_file_sink : public base_sink < Mutex >
|
||||
{
|
||||
public:
|
||||
explicit simple_file_sink(const std::string &filename,
|
||||
bool force_flush=false):
|
||||
bool force_flush = false) :
|
||||
_file_helper(force_flush)
|
||||
{
|
||||
_file_helper.open(filename);
|
||||
@ -64,14 +62,14 @@ typedef simple_file_sink<details::null_mutex> simple_file_sink_st;
|
||||
|
||||
/*
|
||||
* Rotating file sink based on size
|
||||
*/
|
||||
*/
|
||||
template<class Mutex>
|
||||
class rotating_file_sink : public base_sink<Mutex>
|
||||
class rotating_file_sink : public base_sink < Mutex >
|
||||
{
|
||||
public:
|
||||
rotating_file_sink(const std::string &base_filename, const std::string &extension,
|
||||
std::size_t max_size, std::size_t max_files,
|
||||
bool force_flush=false):
|
||||
bool force_flush = false) :
|
||||
_base_filename(base_filename),
|
||||
_extension(extension),
|
||||
_max_size(max_size),
|
||||
@ -82,12 +80,11 @@ public:
|
||||
_file_helper.open(calc_filename(_base_filename, 0, _extension));
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
void _sink_it(const details::log_msg& msg) override
|
||||
{
|
||||
_current_size += msg.formatted.size();
|
||||
if (_current_size > _max_size)
|
||||
if (_current_size > _max_size)
|
||||
{
|
||||
_rotate();
|
||||
_current_size = msg.formatted.size();
|
||||
@ -95,11 +92,10 @@ protected:
|
||||
_file_helper.write(msg);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
|
||||
{
|
||||
details::fmt::MemoryWriter w;
|
||||
fmt::MemoryWriter w;
|
||||
if (index)
|
||||
w.write("{}.{}.{}", filename, index, extension);
|
||||
else
|
||||
@ -107,14 +103,12 @@ private:
|
||||
return w.str();
|
||||
}
|
||||
|
||||
|
||||
// Rotate files:
|
||||
// log.txt -> log.1.txt
|
||||
// log.1.txt -> log2.txt
|
||||
// log.2.txt -> log3.txt
|
||||
// log.3.txt -> delete
|
||||
|
||||
|
||||
void _rotate()
|
||||
{
|
||||
_file_helper.close();
|
||||
@ -152,60 +146,70 @@ typedef rotating_file_sink<details::null_mutex>rotating_file_sink_st;
|
||||
* Rotating file sink based on date. rotates at midnight
|
||||
*/
|
||||
template<class Mutex>
|
||||
class daily_file_sink:public base_sink<Mutex>
|
||||
class daily_file_sink :public base_sink < Mutex >
|
||||
{
|
||||
public:
|
||||
explicit daily_file_sink(const std::string& base_filename,
|
||||
const std::string& extension,
|
||||
bool force_flush=false):
|
||||
_base_filename(base_filename),
|
||||
//create daily file sink which rotates on given time
|
||||
daily_file_sink(
|
||||
const std::string& base_filename,
|
||||
const std::string& extension,
|
||||
int rotation_hour,
|
||||
int rotation_minute,
|
||||
bool force_flush = false) : _base_filename(base_filename),
|
||||
_extension(extension),
|
||||
_midnight_tp (_calc_midnight_tp() ),
|
||||
_rotation_h(rotation_hour),
|
||||
_rotation_m(rotation_minute),
|
||||
_file_helper(force_flush)
|
||||
{
|
||||
if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
|
||||
throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
|
||||
_rotation_tp = _next_rotation_tp();
|
||||
_file_helper.open(calc_filename(_base_filename, _extension));
|
||||
}
|
||||
|
||||
|
||||
protected:
|
||||
void _sink_it(const details::log_msg& msg) override
|
||||
{
|
||||
if (std::chrono::system_clock::now() >= _midnight_tp)
|
||||
if (std::chrono::system_clock::now() >= _rotation_tp)
|
||||
{
|
||||
_file_helper.close();
|
||||
_file_helper.open(calc_filename(_base_filename, _extension));
|
||||
_midnight_tp = _calc_midnight_tp();
|
||||
_rotation_tp = _next_rotation_tp();
|
||||
}
|
||||
_file_helper.write(msg);
|
||||
}
|
||||
|
||||
private:
|
||||
// Return next midnight's time_point
|
||||
static std::chrono::system_clock::time_point _calc_midnight_tp()
|
||||
std::chrono::system_clock::time_point _next_rotation_tp()
|
||||
{
|
||||
using namespace std::chrono;
|
||||
auto now = system_clock::now();
|
||||
time_t tnow = std::chrono::system_clock::to_time_t(now);
|
||||
tm date = spdlog::details::os::localtime(tnow);
|
||||
date.tm_hour = date.tm_min = date.tm_sec = 0;
|
||||
auto midnight = std::chrono::system_clock::from_time_t(std::mktime(&date));
|
||||
return system_clock::time_point(midnight + hours(24));
|
||||
date.tm_hour = _rotation_h;
|
||||
date.tm_min = _rotation_m;
|
||||
date.tm_sec = 0;
|
||||
auto rotation_time = std::chrono::system_clock::from_time_t(std::mktime(&date));
|
||||
if (rotation_time > now)
|
||||
return rotation_time;
|
||||
else
|
||||
return system_clock::time_point(rotation_time + hours(24));
|
||||
}
|
||||
|
||||
//Create filename for the form basename.YYYY-MM-DD.extension
|
||||
static std::string calc_filename(const std::string& basename, const std::string& extension)
|
||||
{
|
||||
std::tm tm = spdlog::details::os::localtime();
|
||||
details::fmt::MemoryWriter w;
|
||||
w.write("{}.{:04d}-{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, extension);
|
||||
fmt::MemoryWriter w;
|
||||
w.write("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, extension);
|
||||
return w.str();
|
||||
}
|
||||
|
||||
std::string _base_filename;
|
||||
std::string _extension;
|
||||
std::chrono::system_clock::time_point _midnight_tp;
|
||||
int _rotation_h;
|
||||
int _rotation_m;
|
||||
std::chrono::system_clock::time_point _rotation_tp;
|
||||
details::file_helper _file_helper;
|
||||
|
||||
};
|
||||
|
||||
typedef daily_file_sink<std::mutex> daily_file_sink_mt;
|
||||
|
@ -37,9 +37,14 @@ namespace sinks
|
||||
template <class Mutex>
|
||||
class stdout_sink : public ostream_sink<Mutex>
|
||||
{
|
||||
using MyType = stdout_sink<Mutex>;
|
||||
public:
|
||||
stdout_sink() : ostream_sink<Mutex>(std::cout, true) {}
|
||||
|
||||
static std::shared_ptr<MyType> instance()
|
||||
{
|
||||
static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
|
||||
return instance;
|
||||
}
|
||||
};
|
||||
|
||||
typedef stdout_sink<details::null_mutex> stdout_sink_st;
|
||||
@ -49,8 +54,15 @@ typedef stdout_sink<std::mutex> stdout_sink_mt;
|
||||
template <class Mutex>
|
||||
class stderr_sink : public ostream_sink<Mutex>
|
||||
{
|
||||
using MyType = stderr_sink<Mutex>;
|
||||
public:
|
||||
stderr_sink() : ostream_sink<Mutex>(std::cerr, true) {}
|
||||
static std::shared_ptr<MyType> instance()
|
||||
{
|
||||
static std::shared_ptr<MyType> instance = std::make_shared<MyType>();
|
||||
return instance;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
typedef stderr_sink<std::mutex> stderr_sink_mt;
|
||||
|
@ -28,16 +28,12 @@
|
||||
|
||||
#pragma once
|
||||
|
||||
|
||||
|
||||
#include "tweakme.h"
|
||||
#include "common.h"
|
||||
#include "logger.h"
|
||||
|
||||
|
||||
|
||||
namespace spdlog
|
||||
{
|
||||
|
||||
// Return an existing logger or nullptr if a logger with such name doesn't exist.
|
||||
// Examples:
|
||||
//
|
||||
@ -55,7 +51,7 @@ void set_pattern(const std::string& format_string);
|
||||
void set_formatter(formatter_ptr f);
|
||||
|
||||
//
|
||||
// Set global logging level for
|
||||
// Set global logging level for
|
||||
//
|
||||
void set_level(level::level_enum log_level);
|
||||
|
||||
@ -69,7 +65,7 @@ void set_level(level::level_enum log_level);
|
||||
// async_overflow_policy::block_retry - if queue is full, block until queue has room for the new log entry.
|
||||
// async_overflow_policy::discard_log_msg - never block and discard any new messages when queue overflows.
|
||||
//
|
||||
// worker_warmup_cb (optional):
|
||||
// worker_warmup_cb (optional):
|
||||
// callback function that will be called in worker thread upon start (can be used to init stuff like thread affinity)
|
||||
//
|
||||
void set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy = async_overflow_policy::block_retry, const std::function<void()>& worker_warmup_cb = nullptr);
|
||||
@ -78,20 +74,20 @@ void set_async_mode(size_t queue_size, const async_overflow_policy overflow_poli
|
||||
void set_sync_mode();
|
||||
|
||||
//
|
||||
// Create multi/single threaded rotating file logger
|
||||
// Create and register multi/single threaded rotating file logger
|
||||
//
|
||||
std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush = false);
|
||||
std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const std::string& filename, size_t max_file_size, size_t max_files, bool force_flush = false);
|
||||
|
||||
//
|
||||
// Create file logger which creates new file at midnight):
|
||||
// Create file logger which creates new file on the given time (default in midnight):
|
||||
//
|
||||
std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const std::string& filename, bool force_flush = false);
|
||||
std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const std::string& filename, bool force_flush = false);
|
||||
std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false);
|
||||
std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const std::string& filename, int hour=0, int minute=0, bool force_flush = false);
|
||||
|
||||
|
||||
//
|
||||
// Create stdout/stderr loggers
|
||||
// Create and register stdout/stderr loggers
|
||||
//
|
||||
std::shared_ptr<logger> stdout_logger_mt(const std::string& logger_name);
|
||||
std::shared_ptr<logger> stdout_logger_st(const std::string& logger_name);
|
||||
@ -100,50 +96,27 @@ std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name);
|
||||
|
||||
|
||||
//
|
||||
// Create a syslog logger
|
||||
// Create and register a syslog logger
|
||||
//
|
||||
#ifdef __linux__
|
||||
std::shared_ptr<logger> syslog_logger(const std::string& logger_name, const std::string& ident = "", int syslog_option = 0);
|
||||
#endif
|
||||
|
||||
|
||||
// Create a logger with multiple sinks
|
||||
// Create and register a logger with multiple sinks
|
||||
std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks);
|
||||
template<class It>
|
||||
std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end);
|
||||
|
||||
|
||||
// Create a logger with templated sink type
|
||||
// Create and register a logger with templated sink type
|
||||
// Example: spdlog::create<daily_file_sink_st>("mylog", "dailylog_filename", "txt");
|
||||
template <typename Sink, typename... Args>
|
||||
std::shared_ptr<spdlog::logger> create(const std::string& logger_name, const Args&...);
|
||||
|
||||
//
|
||||
// Trace & debug macros to be switched on/off at compile time for zero cost debug statements.
|
||||
// Note: using these mactors overrides the runtime log threshold of the logger.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// Enable debug macro, must be defined before including spdlog.h
|
||||
// #define SPDLOG_DEBUG_ON
|
||||
// include "spdlog/spdlog.h"
|
||||
// SPDLOG_DEBUG(my_logger, "Some debug message {} {}", 1, 3.2);
|
||||
//
|
||||
|
||||
#ifdef SPDLOG_TRACE_ON
|
||||
#define SPDLOG_TRACE(logger, ...) logger->force_log(spdlog::level::trace, __VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")";
|
||||
#else
|
||||
#define SPDLOG_TRACE(logger, ...)
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef SPDLOG_DEBUG_ON
|
||||
#define SPDLOG_DEBUG(logger, ...) logger->force_log(spdlog::level::debug, __VA_ARGS__)
|
||||
#else
|
||||
#define SPDLOG_DEBUG(logger, ...)
|
||||
#endif
|
||||
|
||||
|
||||
// Register the given logger with the given name
|
||||
void register_logger(std::shared_ptr<logger> logger);
|
||||
|
||||
// Drop the reference to the given logger
|
||||
void drop(const std::string &name);
|
||||
@ -151,6 +124,31 @@ void drop(const std::string &name);
|
||||
// Drop all references
|
||||
void drop_all();
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// Macros to be display source file & line
|
||||
// Trace & Debug can be switched on/off at compile time for zero cost debug statements.
|
||||
// Uncomment SPDLOG_DEBUG_ON/SPDLOG_TRACE_ON in teakme.h to enable.
|
||||
//
|
||||
// Example:
|
||||
// spdlog::set_level(spdlog::level::debug);
|
||||
// SPDLOG_DEBUG(my_logger, "Some debug message {} {}", 1, 3.2);
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#ifdef SPDLOG_TRACE_ON
|
||||
#define SPDLOG_TRACE(logger, ...) logger->trace(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")";
|
||||
#else
|
||||
#define SPDLOG_TRACE(logger, ...)
|
||||
#endif
|
||||
|
||||
#ifdef SPDLOG_DEBUG_ON
|
||||
#define SPDLOG_DEBUG(logger, ...) logger->debug(__VA_ARGS__) << " (" << __FILE__ << " #" << __LINE__ <<")";
|
||||
#else
|
||||
#define SPDLOG_DEBUG(logger, ...)
|
||||
#endif
|
||||
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
66
include/spdlog/tweakme.h
Normal file
66
include/spdlog/tweakme.h
Normal file
@ -0,0 +1,66 @@
|
||||
/*************************************************************************/
|
||||
/* spdlog - an extremely fast and easy to use c++11 logging library. */
|
||||
/* Copyright (c) 2014 Gabi Melman. */
|
||||
/* */
|
||||
/* Permission is hereby granted, free of charge, to any person obtaining */
|
||||
/* a copy of this software and associated documentation files (the */
|
||||
/* "Software"), to deal in the Software without restriction, including */
|
||||
/* without limitation the rights to use, copy, modify, merge, publish, */
|
||||
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
||||
/* permit persons to whom the Software is furnished to do so, subject to */
|
||||
/* the following conditions: */
|
||||
/* */
|
||||
/* The above copyright notice and this permission notice shall be */
|
||||
/* included in all copies or substantial portions of the Software. */
|
||||
/* */
|
||||
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
||||
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
||||
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
||||
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
||||
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
||||
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
||||
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
||||
/*************************************************************************/
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Edit this file to squeeze every last drop of performance out of spdlog.
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Under Linux, the much faster CLOCK_REALTIME_COARSE clock can be used.
|
||||
// This clock is less accurate - can be off by dozens of millis - depending on the kernel HZ
|
||||
// Uncomment to use it instead of the regular (but slower) clock.
|
||||
// #define SPDLOG_CLOCK_COARSE
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Uncomment if date/time logging is not needed.
|
||||
// This will prevent spdlog from quering the clock on each log call.
|
||||
// #define SPDLOG_NO_DATETIME
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Uncomment if thread id logging is not needed (i.e. no %t in the log pattern)
|
||||
// This will prevent spdlog from quering the thread id on each log call.
|
||||
// #define SPDLOG_NO_THREAD_ID
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Uncomment if logger name logging is not needed.
|
||||
// This will prevent spdlog from copying the logger name on each log call.
|
||||
// #define SPDLOG_NO_NAME
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// Uncomment to enable the SPDLOG_DEBUG/SPDLOG_TRACE macros
|
||||
// #define SPDLOG_DEBUG_ON
|
||||
// #define SPDLOG_TRACE_ON
|
||||
///////////////////////////////////////////////////////////////////////////////
|
Loading…
Reference in New Issue
Block a user