style

Added the ability to truncate the basic file logger.

README.md

@@ -10,11 +10,11 @@ Just copy the source [folder](https://github.com/gabime/spdlog/tree/master/inclu
  * Linux (gcc 4.8.1+, clang 3.5+)
  * Windows (visual studio 2013+, cygwin/mingw with g++ 4.9.1+)
  * Mac OSX (clang 3.5+)
+ * Solaris (gcc 5.2.0+)
 
 ##Features
 * Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below).
-* Headers only.
+* Headers only, just copy and use.
-* No dependencies - just copy and use.
 * Feature rich [call style](#usage-example) using the excellent [fmt](https://github.com/fmtlib/fmt) library.
 * Extremely fast asynchronous mode (optional) - using lockfree queues and other tricks to reach millions of calls/sec.
 * [Custom](https://github.com/gabime/spdlog/wiki/3.-Custom-formatting) formatting.
@@ -23,7 +23,7 @@ Just copy the source [folder](https://github.com/gabime/spdlog/tree/master/inclu
     * Rotating log files.
     * Daily log files.
     * Console logging (colors supported).
-    * Linux syslog.
+    * syslog.
     * Easily extendable with custom log targets  (just implement a single function in the [sink](include/spdlog/sinks/sink.h) interface).
 * Severity based filtering - threshold levels can be modified in runtime as well as in compile time.
 
@@ -57,22 +57,36 @@ Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes
 
 ## Usage Example
 ```c++
-#include <iostream>
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+//
+// spdlog usage example
+//
 #include "spdlog/spdlog.h"
 
+#include <iostream>
+#include <memory>
+
+void async_example();
+void syslog_example();
+void user_defined_example();
+void err_handler_example();
+
+namespace spd = spdlog;
 int main(int, char*[])
 {
-    namespace spd = spdlog;
     try
     {
-        // console logger (multithreaded and with color)
+        // Multithreaded color console
         auto console = spd::stdout_logger_mt("console", true);
         console->info("Welcome to spdlog!");
-        console->info("An info message example {}..", 1);        
+        console->error("An info message example {}..", 1);
 
         // Formatting examples
-        console->info("Easy padding in numbers like {:08d}", 12);
+        console->warn("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->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
         console->info("Support for floats {:03.2f}", 1.23456);
         console->info("Positional args are {1} {0}..", "too", "supported");
 
@@ -80,72 +94,110 @@ int main(int, char* [])
         console->info("{:>30}", "right aligned");
         console->info("{:^30}", "centered");
 
-        //
+        spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function");
+
         // Runtime log levels
-        //
         spd::set_level(spd::level::info); //Set global log level to info
         console->debug("This message shold not be displayed!");
         console->set_level(spd::level::debug); // Set specific logger's log level
-        console->debug("Now it should..");
+        console->debug("This message shold be displayed..");
 
-        //
+        // Create basic file logger (not rotated)
-        // Create a basic multithreaded file logger (or "basic_logger_st" for single threaded logger)
-        //
         auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic.txt");
         my_logger->info("Some log message");
 
-        //
+
         // Create a file rotating logger with 5mb size max and 3 rotated files
-        //
         auto rotating_logger = spd::rotating_logger_mt("some_logger_name", "logs/mylogfile", 1048576 * 5, 3);
         for (int i = 0; i < 10; ++i)
             rotating_logger->info("{} * {} equals {:>10}", i, i, i*i);
 
-        //
         // Create a daily logger - a new file is created every day on 2:30am
-        //
         auto daily_logger = spd::daily_logger_mt("daily_logger", "logs/daily", 2, 30);
+        daily_logger->info(123.44);
 
-        //
         // Customize msg format for all messages
-        //
         spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
         rotating_logger->info("This is another message with custom format");
 
-        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..
-        //
+        async_example();
-        size_t q_size = 8192; //queue size must be power of 2
-        spdlog::set_async_mode(q_size);
-        auto async_file= spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
-        async_file->info("This is async log..Should be very fast!");
 
-        //
+        // syslog example. linux/osx only..
-        // syslog example. linux only..
+        syslog_example();
-        //
-        #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
 
+        // Log user-defined types example..
+        user_defined_example();
+
+        // Change default log error handler
+        err_handler_example();
+
+        // Apply a function on all registered loggers
+        spd::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->info("End of example."); });
+	
+        // Release and close all loggers
+        spdlog::drop_all();
     }
+	// Exceptions will only be thrown upon failed logger or sink construction (not during logging)
     catch (const spd::spdlog_ex& ex)
     {
-        std::cout << "Log failed: " << ex.what() << std::endl;
+        std::cout << "Log init failed: " << ex.what() << std::endl;
+        return 1;
     }    
 }
 
+void async_example()
+{
+    size_t q_size = 4096; //queue size must be power of 2
+    spdlog::set_async_mode(q_size);
+    auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
+    for (int i = 0; i < 100; ++i)
+        async_file->info("Async message #{}", i);
+}
+
+//syslog example
+void syslog_example()
+{
+#ifdef SPDLOG_ENABLE_SYSLOG 
+    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..");
+#endif
+}
+
+// user defined types logging by implementing operator<<
+struct my_type
+{
+    int i;
+    template<typename OStream>
+    friend OStream& operator<<(OStream& os, const my_type &c)
+    {
+        return os << "[my_type i="<<c.i << "]";
+    }
+};
+
+#include <spdlog/fmt/ostr.h> // must be included
+void user_defined_example()
+{
+    spd::get("console")->info("user defined type: {}", my_type { 14 });
+}
+
+//
+//custom error handler
+//
+void err_handler_example()
+{	
+	spdlog::set_error_handler([](const std::string& msg) {
+		std::cerr << "my err handler: " << msg << std::endl;
+	}); 
+	// (or logger->set_error_handler(..) to set for specific logger)
+}
 
 ```
 

example/example.cpp

@@ -5,15 +5,16 @@
 //
 // spdlog usage example
 //
+//
 #include "spdlog/spdlog.h"
 
-#include <cstdlib> // EXIT_FAILURE
 #include <iostream>
 #include <memory>
 
 void async_example();
 void syslog_example();
 void user_defined_example();
+void err_handler_example();
 
 namespace spd = spdlog;
 int main(int, char*[])
@@ -61,7 +62,6 @@ int main(int, char*[])
         spd::set_pattern("*** [%H:%M:%S %z] [thread %t] %v ***");
         rotating_logger->info("This is another message with custom format");
 
-
         // Compile time debug or trace macros.
         // Enabled #ifdef SPDLOG_DEBUG_ON or #ifdef SPDLOG_TRACE_ON
         SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
@@ -71,26 +71,32 @@ int main(int, char*[])
         // Just call spdlog::set_async_mode(q_size) and all created loggers from now on will be asynchronous..
         async_example();
 
-        // syslog example. linux/osx only..
+        // syslog example. linux/osx only
         syslog_example();
 
-        // log user-defined types example..
+        // Log user-defined types example
         user_defined_example();
 
+        // Change default log error handler
+        err_handler_example();
+
+        // Apply a function on all registered loggers
+        spd::apply_all([&](std::shared_ptr<spdlog::logger> l)
+        {
+            l->info("End of example.");
+        });
 
         // Release and close all loggers
         spdlog::drop_all();
     }
-
+    // Exceptions will only be thrown upon failed logger or sink construction (not during logging)
     catch (const spd::spdlog_ex& ex)
     {
-        std::cout << "Log failed: " << ex.what() << std::endl;
+        std::cout << "Log init failed: " << ex.what() << std::endl;
-        return EXIT_FAILURE;
+        return 1;
     }
-    return EXIT_SUCCESS;
 }
 
-
 void async_example()
 {
     size_t q_size = 4096; //queue size must be power of 2
@@ -100,13 +106,13 @@ void async_example()
         async_file->info("Async message #{}", i);
 }
 
-//syslog example (linux/osx only)
+//syslog example (linux/osx/freebsd)
 void syslog_example()
 {
-#if defined (__linux__) || defined(__APPLE__)
+#ifdef SPDLOG_ENABLE_SYSLOG
     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!");
+    syslog_logger->warn("This is warning that will end up in syslog.");
 #endif
 }
 
@@ -127,3 +133,16 @@ void user_defined_example()
     spd::get("console")->info("user defined type: {}", my_type { 14 });
 }
 
+//
+//custom error handler
+//
+void err_handler_example()
+{
+    //can be set globaly or per logger(logger->set_error_handler(..))
+    spdlog::set_error_handler([](const std::string& msg)
+    {
+        std::cerr << "my err handler: " << msg << std::endl;
+    });
+    spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
+}
+

include/spdlog/async_logger.h

@@ -60,7 +60,8 @@ public:
                  const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
                  const std::function<void()>& worker_teardown_cb = nullptr);
 
-
+    //Wait for the queue to be empty, and flush synchronously
+    //Warning: this can potentialy last forever as we wait it to complete
     void flush() override;
 protected:
     void _sink_it(details::log_msg& msg) override;

include/spdlog/common.h

@@ -11,6 +11,8 @@
 #include <memory>
 #include <atomic>
 #include <exception>
+#include<functional>
+
 #if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
 #include <codecvt>
 #include <locale>
@@ -58,6 +60,7 @@ using level_t = details::null_atomic_int;
 using level_t = std::atomic_int;
 #endif
 
+using log_err_handler = std::function<void(const std::string &err_msg)>;
 
 //Log level enum
 namespace level

include/spdlog/details/async_log_helper.h

@@ -120,6 +120,7 @@ public:
     async_log_helper(formatter_ptr formatter,
                      const std::vector<sink_ptr>& sinks,
                      size_t queue_size,
+                     const log_err_handler err_handler,
                      const async_overflow_policy overflow_policy = async_overflow_policy::block_retry,
                      const std::function<void()>& worker_warmup_cb = nullptr,
                      const std::chrono::milliseconds& flush_interval_ms = std::chrono::milliseconds::zero(),
@@ -142,14 +143,13 @@ private:
     // queue of messages to log
     q_type _q;
 
+    log_err_handler _err_handler;
+
     bool _flush_requested;
 
     bool _terminate_requested;
 
 
-    // last exception thrown from the worker thread
-    std::shared_ptr<spdlog_ex> _last_workerthread_ex;
-
     // overflow policy
     const async_overflow_policy _overflow_policy;
 
@@ -167,9 +167,6 @@ private:
 
     void push_msg(async_msg&& new_msg);
 
-    // throw last worker thread exception or if worker thread is not active
-    void throw_if_bad_worker();
-
     // worker thread main loop
     void worker_loop();
 
@@ -182,6 +179,9 @@ private:
     // sleep,yield or return immediatly using the time passed since last message as a hint
     static void sleep_or_yield(const spdlog::log_clock::time_point& now, const log_clock::time_point& last_op_time);
 
+    // wait until the queue is empty
+    void wait_empty_q();
+
 };
 }
 }
@@ -193,6 +193,7 @@ inline spdlog::details::async_log_helper::async_log_helper(
     formatter_ptr formatter,
     const std::vector<sink_ptr>& sinks,
     size_t queue_size,
+    log_err_handler err_handler,
     const async_overflow_policy overflow_policy,
     const std::function<void()>& worker_warmup_cb,
     const std::chrono::milliseconds& flush_interval_ms,
@@ -200,6 +201,7 @@ inline spdlog::details::async_log_helper::async_log_helper(
     _formatter(formatter),
     _sinks(sinks),
     _q(queue_size),
+    _err_handler(err_handler),
     _flush_requested(false),
     _terminate_requested(false),
     _overflow_policy(overflow_policy),
@@ -233,7 +235,6 @@ inline void spdlog::details::async_log_helper::log(const details::log_msg& msg)
 
 inline void spdlog::details::async_log_helper::push_msg(details::async_log_helper::async_msg&& new_msg)
 {
-    throw_if_bad_worker();
     if (!_q.enqueue(std::move(new_msg)) && _overflow_policy != async_overflow_policy::discard_log_msg)
     {
         auto last_op_time = details::os::now();
@@ -248,9 +249,12 @@ inline void spdlog::details::async_log_helper::push_msg(details::async_log_helpe
 
 }
 
+//wait for the queue be empty and request flush from its sinks
 inline void spdlog::details::async_log_helper::flush()
 {
+    wait_empty_q();
     push_msg(async_msg(async_msg_type::flush));
+    wait_empty_q(); //make sure the above flush message was processed
 }
 
 inline void spdlog::details::async_log_helper::worker_loop()
@@ -265,11 +269,11 @@ inline void spdlog::details::async_log_helper::worker_loop()
     }
     catch (const std::exception &ex)
     {
-        _last_workerthread_ex = std::make_shared<spdlog_ex>(std::string("async_logger worker thread exception: ") + ex.what());
+        _err_handler(ex.what());
     }
     catch (...)
     {
-        _last_workerthread_ex = std::make_shared<spdlog_ex>("async_logger worker thread exception");
+        _err_handler("Unknown exception");
     }
 }
 
@@ -362,14 +366,15 @@ inline void spdlog::details::async_log_helper::sleep_or_yield(const spdlog::log_
     return sleep_for(milliseconds(200));
 }
 
-// throw if the worker thread threw an exception or not active
+// wait for the queue to be empty
-inline void spdlog::details::async_log_helper::throw_if_bad_worker()
+inline void spdlog::details::async_log_helper::wait_empty_q()
 {
-    if (_last_workerthread_ex)
+    auto last_op = details::os::now();
+    while (_q.approx_size() > 0)
     {
-        auto ex = std::move(_last_workerthread_ex);
+        sleep_or_yield(details::os::now(), last_op);
-        throw *ex;
     }
+
 }
 
 
@@ -378,3 +383,4 @@ inline void spdlog::details::async_log_helper::throw_if_bad_worker()
 
 
 
+

include/spdlog/details/async_logger_impl.h

@@ -26,7 +26,7 @@ inline spdlog::async_logger::async_logger(const std::string& logger_name,
         const std::chrono::milliseconds& flush_interval_ms,
         const std::function<void()>& worker_teardown_cb) :
     logger(logger_name, begin, end),
-    _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb))
+    _async_log_helper(new details::async_log_helper(_formatter, _sinks, queue_size, _err_handler, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb))
 {
 }
 
@@ -72,6 +72,17 @@ inline void spdlog::async_logger::_set_pattern(const std::string& pattern)
 
 
 inline void spdlog::async_logger::_sink_it(details::log_msg& msg)
+{
+    try
     {
         _async_log_helper->log(msg);
     }
+    catch (const std::exception &ex)
+    {
+        _err_handler(ex.what());
+    }
+    catch (...)
+    {
+        _err_handler("Unknown exception");
+    }
+}

include/spdlog/details/logger_impl.h

@@ -6,10 +6,12 @@
 #pragma once
 
 #include <spdlog/logger.h>
+#include <spdlog/sinks/stdout_sinks.h>
 
 #include <memory>
 #include <string>
 
+
 // create logger with given name, sinks and the default pattern formatter
 // all other ctors will call this one
 template<class It>
@@ -18,15 +20,19 @@ inline spdlog::logger::logger(const std::string& logger_name, const It& begin, c
     _sinks(begin, end),
     _formatter(std::make_shared<pattern_formatter>("%+"))
 {
-
-    // no support under vs2013 for member initialization for std::atomic
     _level = level::info;
     _flush_level = level::off;
+    _last_err_time = 0;
+    _err_handler = [this](const std::string &msg)
+    {
+        this->_default_err_handler(msg);
+    };
 }
 
 // ctor with sinks as init list
 inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list):
-    logger(logger_name, sinks_list.begin(), sinks_list.end()) {}
+    logger(logger_name, sinks_list.begin(), sinks_list.end())
+{}
 
 
 // ctor with single sink
@@ -34,7 +40,8 @@ inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr s
     logger(logger_name,
 {
     single_sink
-}) {}
+})
+{}
 
 
 inline spdlog::logger::~logger() = default;
@@ -56,28 +63,40 @@ inline void spdlog::logger::log(level::level_enum lvl, const char* fmt, const Ar
 {
     if (!should_log(lvl)) return;
 
-    details::log_msg log_msg(&_name, lvl);
     try
     {
+        details::log_msg log_msg(&_name, lvl);
         log_msg.raw.write(fmt, args...);
-    }
-    catch (fmt::FormatError &ex)
-    {
-        throw spdlog::spdlog_ex(std::string("format error in \"") + fmt + "\": " + ex.what());
-    }
-
         _sink_it(log_msg);
-
+    }
+    catch (const std::exception &ex)
+    {
+        _err_handler(ex.what());
+    }
+    catch (...)
+    {
+        _err_handler("Unknown exception");
+    }
 }
 
 template <typename... Args>
 inline void spdlog::logger::log(level::level_enum lvl, const char* msg)
 {
     if (!should_log(lvl)) return;
-
+    try
+    {
         details::log_msg log_msg(&_name, lvl);
         log_msg.raw << msg;
         _sink_it(log_msg);
+    }
+    catch (const std::exception &ex)
+    {
+        _err_handler(ex.what());
+    }
+    catch (...)
+    {
+        _err_handler("Unknown exception");
+    }
 
 }
 
@@ -85,11 +104,20 @@ template<typename T>
 inline void spdlog::logger::log(level::level_enum lvl, const T& msg)
 {
     if (!should_log(lvl)) return;
-
+    try
+    {
         details::log_msg log_msg(&_name, lvl);
         log_msg.raw << msg;
         _sink_it(log_msg);
-
+    }
+    catch (const std::exception &ex)
+    {
+        _err_handler(ex.what());
+    }
+    catch (...)
+    {
+        _err_handler("Unknown exception");
+    }
 }
 
 
@@ -185,6 +213,17 @@ inline void spdlog::logger::set_level(spdlog::level::level_enum log_level)
     _level.store(log_level);
 }
 
+inline void spdlog::logger::set_error_handler(spdlog::log_err_handler err_handler)
+{
+    _err_handler = err_handler;
+}
+
+inline spdlog::log_err_handler spdlog::logger::error_handler()
+{
+    return _err_handler;
+}
+
+
 inline void spdlog::logger::flush_on(level::level_enum log_level)
 {
     _flush_level.store(log_level);
@@ -205,6 +244,7 @@ inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) cons
 //
 inline void spdlog::logger::_sink_it(details::log_msg& msg)
 {
+
     _formatter->format(msg);
     for (auto &sink : _sinks)
         sink->log(msg);
@@ -228,3 +268,17 @@ inline void spdlog::logger::flush()
     for (auto& sink : _sinks)
         sink->flush();
 }
+
+inline void spdlog::logger::_default_err_handler(const std::string &msg)
+{
+    auto now = time(nullptr);
+    if (now - _last_err_time < 60)
+        return;
+    auto tm_time = details::os::localtime(now);
+    char date_buf[100];
+    std::strftime(date_buf, sizeof(date_buf), "%Y-%m-%d %H:%M:%S", &tm_time);
+    details::log_msg  err_msg;
+    err_msg.formatted.write("[*** LOG ERROR ***] [{}] [{}] [{}]{}", name(), msg, date_buf, details::os::eol);
+    sinks::stderr_sink_mt::instance()->log(err_msg);
+    _last_err_time = now;
+}

include/spdlog/details/mpmc_bounded_q.h

@@ -60,7 +60,8 @@ public:
 
     using item_type = T;
     mpmc_bounded_queue(size_t buffer_size)
-        : buffer_(new cell_t [buffer_size]),
+        :max_size_(buffer_size),
+         buffer_(new cell_t [buffer_size]),
          buffer_mask_(buffer_size - 1)
     {
         //queue size must be power of two
@@ -132,6 +133,16 @@ public:
         return true;
     }
 
+    size_t approx_size()
+    {
+        size_t first_pos = dequeue_pos_.load(std::memory_order_relaxed);
+        size_t last_pos = enqueue_pos_.load(std::memory_order_relaxed);
+        if (last_pos <= first_pos)
+            return 0;
+        auto size = last_pos - first_pos;
+        return size < max_size_ ? size : max_size_;
+    }
+
 private:
     struct cell_t
     {
@@ -139,6 +150,8 @@ private:
         T                     data_;
     };
 
+    size_t const max_size_;
+
     static size_t const     cacheline_size = 64;
     typedef char            cacheline_pad_t [cacheline_size];
 
@@ -151,8 +164,8 @@ private:
     std::atomic<size_t>     dequeue_pos_;
     cacheline_pad_t         pad3_;
 
-    mpmc_bounded_queue(mpmc_bounded_queue const&);
+    mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
-    void operator = (mpmc_bounded_queue const&);
+    void operator= (mpmc_bounded_queue const&) = delete;
 };
 
 } // ns details

include/spdlog/details/os.h

@@ -38,8 +38,10 @@
 #include <unistd.h>
 #include <chrono>
 
-#else
+#elif __FreeBSD__
+#include <sys/thr.h> //Use thr_self() syscall under FreeBSD to get thread id
 
+#else
 #include <thread>
 
 #endif
@@ -210,7 +212,7 @@ inline size_t filesize(FILE *f)
 #else // unix
     int fd = fileno(f);
     //64 bits(but not in osx, where fstat64 is deprecated)
-	#if !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) 
+#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__))
     struct stat64 st;
     if (fstat64(fd, &st) == 0)
         return st.st_size;
@@ -248,7 +250,43 @@ inline int utc_minutes_offset(const std::tm& tm = details::os::localtime())
         offset -= tzinfo.StandardBias;
     return offset;
 #else
-    return static_cast<int>(tm.tm_gmtoff / 60);
+
+#if defined(sun) || defined(__sun)
+    // 'tm_gmtoff' field is BSD extension and it's missing on SunOS/Solaris
+    struct helper
+    {
+        static long int calculate_gmt_offset(const std::tm & localtm = details::os::localtime(), const std::tm & gmtm = details::os::gmtime())
+        {
+            int local_year = localtm.tm_year + (1900 - 1);
+            int gmt_year = gmtm.tm_year + (1900 - 1);
+
+            long int days = (
+                                // difference in day of year
+                                localtm.tm_yday - gmtm.tm_yday
+
+                                // + intervening leap days
+                                + ((local_year >> 2) - (gmt_year >> 2))
+                                - (local_year / 100 - gmt_year / 100)
+                                + ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
+
+                                // + difference in years * 365 */
+                                + (long int)(local_year - gmt_year) * 365
+                            );
+
+            long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
+            long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
+            long int secs = (60 * mins) + (localtm.tm_sec - gmtm.tm_sec);
+
+            return secs;
+        }
+    };
+
+    long int offset_seconds = helper::calculate_gmt_offset(tm);
+#else
+    long int offset_seconds = tm.tm_gmtoff;
+#endif
+
+    return static_cast<int>(offset_seconds / 60);
 #endif
 }
 
@@ -263,10 +301,15 @@ inline size_t thread_id()
 #  define SYS_gettid __NR_gettid
 # endif
     return  static_cast<size_t>(syscall(SYS_gettid));
+#elif __FreeBSD__
+    long tid;
+    thr_self(&tid);
+    return static_cast<size_t>(tid);
 #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
 
+
 }
 
 
@@ -299,7 +342,7 @@ inline std::string errno_str(int err_num)
     else
         return "Unkown error";
 
-#elif defined(__APPLE__) || ((_POSIX_C_SOURCE >= 200112L) && ! _GNU_SOURCE) // posix version        
+#elif defined(__FreeBSD__) || defined(__APPLE__) || ((_POSIX_C_SOURCE >= 200112L) && ! _GNU_SOURCE) // posix version
     if (strerror_r(err_num, buf, buf_size) == 0)
         return std::string(buf);
     else

include/spdlog/details/pattern_formatter_impl.h

@@ -26,7 +26,8 @@ namespace details
 class flag_formatter
 {
 public:
-    virtual ~flag_formatter() {}
+    virtual ~flag_formatter()
+    {}
     virtual void format(details::log_msg& msg, const std::tm& tm_time) = 0;
 };
 
@@ -304,7 +305,8 @@ class z_formatter :public flag_formatter
 public:
     const std::chrono::seconds cache_refresh = std::chrono::seconds(5);
 
-    z_formatter() :_last_update(std::chrono::seconds(0)) {}
+    z_formatter():_last_update(std::chrono::seconds(0))
+    {}
     z_formatter(const z_formatter&) = delete;
     z_formatter& operator=(const z_formatter&) = delete;
 
@@ -317,13 +319,21 @@ public:
         // it is very fast (already stored in tm.tm_gmtoff)
         int total_minutes = os::utc_minutes_offset(tm_time);
 #endif
+        bool is_negative = total_minutes < 0;
+        char sign;
+        if (is_negative)
+        {
+            total_minutes = -total_minutes;
+            sign = '-';
+        }
+        else
+        {
+            sign = '+';
+        }
 
         int h = total_minutes / 60;
         int m = total_minutes % 60;
-        if (h >= 0) //minus sign will be printed anyway if negative
+        msg.formatted << sign;
-        {
-            msg.formatted << '+';
-        }
         pad_n_join(msg.formatted, h, m, ':');
     }
 private:
@@ -611,8 +621,7 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
 
 inline void spdlog::pattern_formatter::format(details::log_msg& msg)
 {
-    try
+
-    {
 #ifndef SPDLOG_NO_DATETIME
     auto tm_time = details::os::localtime(log_clock::to_time_t(msg.time));
 #else
@@ -625,8 +634,3 @@ inline void spdlog::pattern_formatter::format(details::log_msg& msg)
     //write eol
     msg.formatted.write(details::os::eol, details::os::eol_size);
 }
-    catch(const fmt::FormatError& e)
-    {
-        throw spdlog_ex(fmt::format("formatting error while processing format string: {}", e.what()));
-    }
-}

include/spdlog/details/registry.h

@@ -60,12 +60,24 @@ public:
         if (_formatter)
             new_logger->set_formatter(_formatter);
 
+        if (_err_handler)
+            new_logger->set_error_handler(_err_handler);
+
         new_logger->set_level(_level);
+
+
         //Add to registry
         _loggers[logger_name] = new_logger;
         return new_logger;
     }
 
+    void apply_all(std::function<void(std::shared_ptr<logger>)> fun)
+    {
+        std::lock_guard<Mutex> lock(_mutex);
+        for (auto &l : _loggers)
+            fun(l.second);
+    }
+
     void drop(const std::string& logger_name)
     {
         std::lock_guard<Mutex> lock(_mutex);
@@ -112,6 +124,13 @@ public:
         _level = log_level;
     }
 
+    void set_error_handler(log_err_handler handler)
+    {
+        for (auto& l : _loggers)
+            l.second->set_error_handler(handler);
+        _err_handler = handler;
+    }
+
     void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
     {
         std::lock_guard<Mutex> lock(_mutex);
@@ -149,6 +168,7 @@ private:
     std::unordered_map <std::string, std::shared_ptr<logger>> _loggers;
     formatter_ptr _formatter;
     level::level_enum _level = level::info;
+    log_err_handler _err_handler;
     bool _async_mode = false;
     size_t _async_q_size = 0;
     async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;

include/spdlog/details/spdlog_impl.h

@@ -36,14 +36,14 @@ inline void spdlog::drop(const std::string &name)
 }
 
 // Create multi/single threaded simple file logger
-inline std::shared_ptr<spdlog::logger> spdlog::basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool force_flush)
+inline std::shared_ptr<spdlog::logger> spdlog::basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool force_flush, bool truncate)
 {
-    return create<spdlog::sinks::simple_file_sink_mt>(logger_name, filename, force_flush);
+    return create<spdlog::sinks::simple_file_sink_mt>(logger_name, filename, force_flush, truncate);
 }
 
-inline std::shared_ptr<spdlog::logger> spdlog::basic_logger_st(const std::string& logger_name, const filename_t& filename, bool force_flush)
+inline std::shared_ptr<spdlog::logger> spdlog::basic_logger_st(const std::string& logger_name, const filename_t& filename, bool force_flush, bool truncate)
 {
-    return create<spdlog::sinks::simple_file_sink_st>(logger_name, filename, force_flush);
+    return create<spdlog::sinks::simple_file_sink_st>(logger_name, filename, force_flush, truncate);
 }
 
 // Create multi/single threaded rotating file logger
@@ -96,7 +96,7 @@ inline std::shared_ptr<spdlog::logger> spdlog::stderr_logger_st(const std::strin
     return create_console_logger(logger_name, sinks::stderr_sink_st::instance(), color);
 }
 
-#if defined(__linux__) || defined(__APPLE__)
+#ifdef SPDLOG_ENABLE_SYSLOG
 // Create syslog logger
 inline std::shared_ptr<spdlog::logger> spdlog::syslog_logger(const std::string& logger_name, const std::string& syslog_ident, int syslog_option)
 {
@@ -147,6 +147,11 @@ inline void spdlog::set_level(level::level_enum log_level)
     return details::registry::instance().set_level(log_level);
 }
 
+inline void spdlog::set_error_handler(log_err_handler handler)
+{
+    return details::registry::instance().set_error_handler(handler);
+}
+
 
 inline void spdlog::set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb)
 {
@@ -158,6 +163,11 @@ inline void spdlog::set_sync_mode()
     details::registry::instance().set_sync_mode();
 }
 
+inline void spdlog::apply_all(std::function<void(std::shared_ptr<logger>)> fun)
+{
+    details::registry::instance().apply_all(fun);
+}
+
 inline void spdlog::drop_all()
 {
     details::registry::instance().drop_all();

include/spdlog/logger.h

@@ -19,7 +19,6 @@
 #include <memory>
 #include <string>
 
-
 namespace spdlog
 {
 
@@ -53,7 +52,6 @@ public:
     template <typename T> void error(const T&);
     template <typename T> void critical(const T&);
 
-
     bool should_log(level::level_enum) const;
     void set_level(level::level_enum);
     level::level_enum level() const;
@@ -61,6 +59,10 @@ public:
     void set_pattern(const std::string&);
     void set_formatter(formatter_ptr);
 
+    // error handler
+    void set_error_handler(log_err_handler);
+    log_err_handler error_handler();
+
     // automatically call flush() if message level >= log_level
     void flush_on(level::level_enum log_level);
     virtual void flush();
@@ -70,11 +72,16 @@ protected:
     virtual void _set_pattern(const std::string&);
     virtual void _set_formatter(formatter_ptr);
 
+    // default error handler: print the error to stderr with the max rate of 1 message/minute
+    virtual void _default_err_handler(const std::string &msg);
+
     const std::string _name;
     std::vector<sink_ptr> _sinks;
     formatter_ptr _formatter;
     spdlog::level_t _level;
     spdlog::level_t _flush_level;
+    log_err_handler _err_handler;
+    std::atomic<time_t> _last_err_time;
 };
 }
 

include/spdlog/sinks/base_sink.h

@@ -7,7 +7,7 @@
 //
 // base sink templated over a mutex (either dummy or realy)
 // concrete implementation should only overrid the _sink_it method.
-// all locking is taken care of here so no locking needed by the implementors..
+// all locking is taken care of here so no locking needed by the implementers..
 //
 
 #include <spdlog/sinks/sink.h>

include/spdlog/sinks/dist_sink.h

@@ -11,10 +11,12 @@
 #include <spdlog/sinks/sink.h>
 
 #include <algorithm>
-#include <memory>
 #include <mutex>
+#include <memory>
 #include <vector>
 
+// Distribution sink (mux). Stores a vector of sinks which get called when log is called
+
 namespace spdlog
 {
 namespace sinks
@@ -29,40 +31,33 @@ public:
     virtual ~dist_sink() = default;
 
 protected:
+    std::vector<std::shared_ptr<sink>> _sinks;
+
     void _sink_it(const details::log_msg& msg) override
     {
-        for (auto iter = _sinks.begin(); iter != _sinks.end(); iter++)
+        for (auto &sink : _sinks)
-            (*iter)->log(msg);
+            sink->log(msg);
     }
 
-    std::vector<std::shared_ptr<sink>> _sinks;
 
 public:
     void flush() override
     {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        for (auto iter = _sinks.begin(); iter != _sinks.end(); iter++)
+        for (auto &sink : _sinks)
-            (*iter)->flush();
+            sink->flush();
     }
 
     void add_sink(std::shared_ptr<sink> sink)
     {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        if (sink &&
-                _sinks.end() == std::find(_sinks.begin(), _sinks.end(), sink))
-        {
         _sinks.push_back(sink);
     }
-    }
 
     void remove_sink(std::shared_ptr<sink> sink)
     {
         std::lock_guard<Mutex> lock(base_sink<Mutex>::_mutex);
-        auto pos = std::find(_sinks.begin(), _sinks.end(), sink);
+        _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), sink), _sinks.end());
-        if (pos != _sinks.end())
-        {
-            _sinks.erase(pos);
-        }
     }
 };
 

include/spdlog/sinks/file_sinks.h

@@ -30,10 +30,11 @@ class simple_file_sink : public base_sink < Mutex >
 {
 public:
     explicit simple_file_sink(const filename_t &filename,
-                              bool force_flush = false) :
+                              bool force_flush = false,
+                              bool truncate = false) :
         _file_helper(force_flush)
     {
-        _file_helper.open(filename);
+        _file_helper.open(filename, truncate);
     }
     void flush() override
     {

include/spdlog/sinks/syslog_sink.h

@@ -5,10 +5,11 @@
 
 #pragma once
 
-#if defined(__linux__) || defined(__APPLE__)
+#include <spdlog/common.h>
+
+#ifdef SPDLOG_ENABLE_SYSLOG
 
 #include <spdlog/sinks/sink.h>
-#include <spdlog/common.h>
 #include <spdlog/details/log_msg.h>
 
 #include <array>

include/spdlog/spdlog.h

@@ -41,6 +41,11 @@ void set_formatter(formatter_ptr f);
 //
 void set_level(level::level_enum log_level);
 
+//
+// Set global error handler
+//
+void set_error_handler(log_err_handler);
+
 //
 // Turn on async mode (off by default) and set the queue size for each async_logger.
 // effective only for loggers created after this call.
@@ -66,8 +71,8 @@ void set_sync_mode();
 //
 // Create and register multi/single basic file logger
 //
-std::shared_ptr<logger> basic_logger_mt(const std::string& logger_name, const filename_t& filename,bool force_flush = false);
+std::shared_ptr<logger> basic_logger_mt(const std::string& logger_name, const filename_t& filename,bool force_flush = false, bool truncate = false);
-std::shared_ptr<logger> basic_logger_st(const std::string& logger_name, const filename_t& filename, bool force_flush = false);
+std::shared_ptr<logger> basic_logger_st(const std::string& logger_name, const filename_t& filename, bool force_flush = false, bool truncate = false);
 
 //
 // Create and register multi/single threaded rotating file logger
@@ -93,7 +98,7 @@ std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name, bool co
 //
 // Create and register a syslog logger
 //
-#if defined(__linux__) || defined(__APPLE__)
+#ifdef SPDLOG_ENABLE_SYSLOG
 std::shared_ptr<logger> syslog_logger(const std::string& logger_name, const std::string& ident = "", int syslog_option = 0);
 #endif
 
@@ -108,7 +113,8 @@ std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_b
 
 
 // Create and register a logger with templated sink type
-// Example: spdlog::create<daily_file_sink_st>("mylog", "dailylog_filename", "txt");
+// 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, Args...);
 
@@ -116,10 +122,15 @@ std::shared_ptr<spdlog::logger> create(const std::string& logger_name, Args...);
 // Register the given logger with the given name
 void register_logger(std::shared_ptr<logger> logger);
 
+// Apply a user defined function on all registered loggers
+// Example:
+// spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->flush();});
+void apply_all(std::function<void(std::shared_ptr<logger>)> fun);
+
 // Drop the reference to the given logger
 void drop(const std::string &name);
 
-// Drop all references
+// Drop all references from the registry
 void drop_all();
 
 

include/spdlog/tweakme.h

@@ -11,6 +11,7 @@
 //
 ///////////////////////////////////////////////////////////////////////////////
 
+
 ///////////////////////////////////////////////////////////////////////////////
 // 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.
@@ -48,7 +49,6 @@
 // #define SPDLOG_NO_NAME
 ///////////////////////////////////////////////////////////////////////////////
 
-
 ///////////////////////////////////////////////////////////////////////////////
 // Uncomment to enable the SPDLOG_DEBUG/SPDLOG_TRACE macros.
 //
@@ -92,3 +92,12 @@
 //
 // #define SPDLOG_FMT_EXTERNAL
 ///////////////////////////////////////////////////////////////////////////////
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Uncomment to enable syslog (disabled by default)
+//
+// #define SPDLOG_ENABLE_SYSLOG
+///////////////////////////////////////////////////////////////////////////////
+
+

tests/errors.cpp

@@ -0,0 +1,63 @@
+/*
+* This content is released under the MIT License as specified in https://raw.githubusercontent.com/gabime/spdlog/master/LICENSE
+*/
+#include "includes.h"
+
+#include<iostream>
+
+
+TEST_CASE("default_error_handler", "[errors]]")
+{
+    prepare_logdir();
+    std::string filename = "logs/simple_log.txt";
+
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
+    logger->set_pattern("%v");
+    logger->info("Test message {} {}", 1);
+    logger->info("Test message {}", 2);
+    logger->flush();
+
+    REQUIRE(file_contents(filename) == std::string("Test message 2\n"));
+    REQUIRE(count_lines(filename) == 1);
+}
+
+
+struct custom_ex {};
+TEST_CASE("custom_error_handler", "[errors]]")
+{
+    prepare_logdir();
+    std::string filename = "logs/simple_log.txt";
+    auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
+    logger->set_error_handler([=](const std::string& msg)
+    {
+        throw custom_ex();
+    });
+    logger->info("Good message #1");
+    REQUIRE_THROWS_AS(logger->info("Bad format msg {} {}", "xxx"), custom_ex);
+    logger->info("Good message #2");
+    REQUIRE(count_lines(filename) == 2);
+}
+
+TEST_CASE("async_error_handler", "[errors]]")
+{
+    prepare_logdir();
+    std::string err_msg("log failed with some msg");
+    spdlog::set_async_mode(128);
+    std::string filename = "logs/simple_async_log.txt";
+    {
+        auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename, true);
+        logger->set_error_handler([=](const std::string& msg)
+        {
+            std::ofstream ofs("logs/custom_err.txt");
+            if (!ofs) throw std::runtime_error("Failed open logs/custom_err.txt");
+            ofs << err_msg;
+        });
+        logger->info("Good message #1");
+        logger->info("Bad format msg {} {}", "xxx");
+        logger->info("Good message #2");
+        spdlog::drop("logger"); //force logger to drain the queue and shutdown
+        spdlog::set_sync_mode();
+    }
+    REQUIRE(count_lines(filename) == 2);
+    REQUIRE(file_contents("logs/custom_err.txt") == err_msg);
+}

tests/format.cpp

@@ -49,24 +49,7 @@ TEST_CASE("log_levels", "[log_levels]")
     REQUIRE(log_info("Hello", spdlog::level::trace) == "Hello");
 }
 
-TEST_CASE("invalid_format", "[format]")
+
-{
-
-    using namespace spdlog::sinks;
-    spdlog::logger null_logger("null_logger", std::make_shared<null_sink_st>());
-    REQUIRE_THROWS_AS(
-        null_logger.info("{} {}", "first"),
-        spdlog::spdlog_ex);
-
-    REQUIRE_THROWS_AS(
-        null_logger.info("{0:f}", "aads"),
-        spdlog::spdlog_ex);
-
-    REQUIRE_THROWS_AS(
-        null_logger.info("{0:kk}", 123),
-        spdlog::spdlog_ex);
-
-}
 
 
 

tests/registry.cpp

@@ -1,6 +1,7 @@
 #include "includes.h"
 
 static const char *tested_logger_name = "null_logger";
+static const char *tested_logger_name2 = "null_logger2";
 
 TEST_CASE("register_drop", "[registry]")
 {
@@ -22,6 +23,34 @@ TEST_CASE("explicit register" "[registry]")
     REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name), spdlog::spdlog_ex);
 }
 
+TEST_CASE("apply_all" "[registry]")
+{
+    spdlog::drop_all();
+    auto logger = std::make_shared<spdlog::logger>(tested_logger_name, std::make_shared<spdlog::sinks::null_sink_st>());
+    spdlog::register_logger(logger);
+    auto logger2 = std::make_shared<spdlog::logger>(tested_logger_name2, std::make_shared<spdlog::sinks::null_sink_st>());
+    spdlog::register_logger(logger2);
+
+    int counter = 0;
+    spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger> l)
+    {
+        counter++;
+    });
+    REQUIRE(counter == 2);
+
+    counter = 0;
+    spdlog::drop(tested_logger_name2);
+    spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger> l)
+    {
+        REQUIRE(l->name() == tested_logger_name);
+        counter++;
+    }
+                     );
+    REQUIRE(counter == 1);
+}
+
+
+
 TEST_CASE("drop" "[registry]")
 {
     spdlog::drop_all();
@@ -34,10 +63,10 @@ TEST_CASE("drop_all" "[registry]")
 {
     spdlog::drop_all();
     spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
-    spdlog::create<spdlog::sinks::null_sink_mt>("name2");
+    spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name2);
     spdlog::drop_all();
     REQUIRE_FALSE(spdlog::get(tested_logger_name));
-    REQUIRE_FALSE(spdlog::get("name2"));
+    REQUIRE_FALSE(spdlog::get(tested_logger_name));
 }
 
 
@@ -51,3 +80,5 @@ TEST_CASE("drop non existing" "[registry]")
     spdlog::drop_all();
 }
 
+
+

tests/tests.vcxproj

@@ -125,6 +125,7 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="errors.cpp" />
     <ClCompile Include="file_helper.cpp" />
     <ClCompile Include="file_log.cpp" />
     <ClCompile Include="format.cpp" />

tests/tests.vcxproj.filters

@@ -33,6 +33,9 @@
     <ClCompile Include="utils.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="errors.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="includes.h">