Merge pull request #4 from gabime/master

Merge with upstream

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:
+## Platforms
-* gcc 4.8.1 and above
+ * Linux (gcc 4.8.1+, clang 3.5+)
-* clang 3.5
+ * Windows (visual studio 2013+, mingw with g++ 4.9.1+)
-* visual studio 2013
+ * Mac OSX (clang 3.5+)
-* mingw with g++ 4.9.x
  
 ##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.
+* Feature rich [call style](#usage-example) using the excellent [cppformat](http://cppformat.github.io/) library.
-* **new!** 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.
+

bench/results.txt

@@ -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

example/bench.cpp

@@ -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)
         {

example/example.cpp

@@ -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
+        //Create console, multithreaded logger
-        spd::set_level(spd::level::debug);
-
-        // Create console, multithreaded logger
         auto console = spd::stdout_logger_mt("console");
-        console->info("Hello {}", 1);
+        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 << "..";
 }
 

include/spdlog/common.h

@@ -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
 {

include/spdlog/details/async_log_helper.h

@@ -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(async_msg&& other) SPDLOG_NOEXCEPT:
-        async_msg& operator=(async_msg& other) = delete;
+        logger_name(std::move(other.logger_name)),
-
+                    level(std::move(other.level)),
-        async_msg(const details::log_msg& m) :
+                    time(std::move(other.time)),
-            logger_name(m.logger_name),
+                    txt(std::move(other.txt))
-            level(m.level),
-            time(m.time),
-            txt(m.raw.data(), m.raw.size())
         {}
 
-        async_msg(async_msg&& other) :
+        async_msg& operator=(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& operator=(async_msg&& other)
         {
             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
+    // 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
+    // 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
+// process next message in the queue
-// Return true if this thread should still be active (no msg with level::off was received)
+// 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)

include/spdlog/details/line_logger.h

@@ -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);
         }
     }

include/spdlog/details/log_msg.h

@@ -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;
 };

include/spdlog/details/os.h

@@ -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

include/spdlog/details/pattern_formatter_impl.h

@@ -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;
@@ -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()));
     }
 }

include/spdlog/details/registry.h

@@ -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;

include/spdlog/details/spdlog_impl.h

@@ -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__

include/spdlog/sinks/file_sinks.h

@@ -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,
+    //create daily file sink which rotates on given time
-                             const std::string& extension,
+    daily_file_sink(
-                             bool force_flush=false):
+        const std::string& base_filename,
-        _base_filename(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
+    std::chrono::system_clock::time_point _next_rotation_tp()
-    static std::chrono::system_clock::time_point _calc_midnight_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;
+        date.tm_hour = _rotation_h;
-        auto midnight = std::chrono::system_clock::from_time_t(std::mktime(&date));
+        date.tm_min = _rotation_m;
-        return system_clock::time_point(midnight + hours(24));
+        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;
+        fmt::MemoryWriter w;
-        w.write("{}.{:04d}-{:02d}-{:02d}.{}", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, extension);
+        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;

include/spdlog/sinks/stdout_sinks.h

@@ -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;

include/spdlog/spdlog.h

@@ -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:
 //
@@ -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_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, 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
+
+
 }
 
 

include/spdlog/tweakme.h

@@ -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
+///////////////////////////////////////////////////////////////////////////////