Support bench under OSX

add async with null sink bench
Removed force_flush arg from everywhere. Use flush_on(level) instead
2025-09-28 17:19:34 +08:00 · 2016-09-18 02:28:41 +03:00 · 2016-09-18 01:51:53 +03:00 · 2016-09-18 00:43:42 +03:00 · 2016-09-18 00:14:56 +03:00 · 2016-09-16 02:58:02 +03:00
47 changed files with 1093 additions and 522 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
-# Auto generated files 
+# Auto generated files
 *.slo
 *.lo
 *.o
@@ -45,6 +45,8 @@ example/*
 !example/example.sln
 !example/example.vcxproj
 !example/CMakeLists.txt
+!example/multisink.cpp
+!example/jni

 # generated files
 generated
--- a/README.md
+++ b/README.md
@@ -10,11 +10,12 @@ 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+)
+ * Android

 ##Features
 * Very fast - performance is the primary goal (see [benchmarks](#benchmarks) below).
-* Headers only.
-* No dependencies - just copy and use.
+* Headers only, 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 +24,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 +58,30 @@ Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes

 ## Usage Example
 ```c++
-#include <iostream>
+
 #include "spdlog/spdlog.h"

-int main(int, char* [])
+#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->info("Welcome to spdlog!");
+        console->info("An info message example {}..", 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);
+        // Formatting examples
+        console->warn("Easy padding in numbers like {:08d}", 12);
+        console->critical("Support for int: {0:d};  hex: {0:x};  oct: {0:o}; bin: {0:b}", 42);
        console->info("Support for floats {:03.2f}", 1.23456);
        console->info("Positional args are {1} {0}..", "too", "supported");

@@ -80,72 +89,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..");
-        
-        //
-        // Create a basic multithreaded file logger (or "basic_logger_st" for single threaded logger)
-        //
+        console->debug("This message shold be displayed..");
+
+        // Create basic file logger (not rotated)
        auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic.txt");
        my_logger->info("Some log message");

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

-        //
-        // 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
-                
+        // syslog example. linux/osx only..
+        syslog_example();
+
+        // Log user-defined types example..
+        user_defined_example();
+
+        // Change default log error handler
+        err_handler_example();
+
+        // Apply a function on all registered loggers
+        spd::apply_all([&](std::shared_ptr<spdlog::logger> l) {l->info("End of example."); });
+	
+        // Release and close all loggers
+        spdlog::drop_all();
    }
+	// Exceptions will only be thrown upon failed logger or sink construction (not during logging)
    catch (const spd::spdlog_ex& ex)
    {
-        std::cout << "Log 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)
+}

 ```

--- a/bench/Makefile
+++ b/bench/Makefile
@@ -1,9 +1,9 @@
 CXX	?= g++
-CXXFLAGS	= -march=native -Wall -Wextra -pedantic -std=c++11 -pthread -Wl,--no-as-needed  -I../include
+CXXFLAGS	= -march=native -Wall -Wextra -pedantic -std=c++11 -pthread -I../include
 CXX_RELEASE_FLAGS = -O3 -flto -DNDEBUG


-binaries=spdlog-bench spdlog-bench-mt spdlog-async zf_log-bench zf_log-bench-mt boost-bench boost-bench-mt glog-bench glog-bench-mt g2log-async easylogging-bench easylogging-bench-mt
+binaries=spdlog-bench spdlog-bench-mt spdlog-async spdlog-null-async boost-bench boost-bench-mt glog-bench glog-bench-mt g2log-async easylogging-bench easylogging-bench-mt

 all: $(binaries)

@@ -17,14 +17,11 @@ spdlog-async: spdlog-async.cpp
 	$(CXX) spdlog-async.cpp -o spdlog-async  $(CXXFLAGS) $(CXX_RELEASE_FLAGS)


-ZF_LOG_FLAGS = -I../../zf_log.git/zf_log/
-zf_log-bench: zf_log-bench.cpp
-	$(CXX) zf_log-bench.cpp -o zf_log-bench  $(CXXFLAGS) $(CXX_RELEASE_FLAGS) $(ZF_LOG_FLAGS)
+spdlog-null-async: spdlog-null-async.cpp
+	$(CXX) spdlog-null-async.cpp -o spdlog-null-async $(CXXFLAGS) $(CXX_RELEASE_FLAGS)

-zf_log-bench-mt: zf_log-bench-mt.cpp
-	$(CXX) zf_log-bench-mt.cpp -o zf_log-bench-mt  $(CXXFLAGS) $(CXX_RELEASE_FLAGS) $(ZF_LOG_FLAGS)
 	
-
+	
 BOOST_FLAGS	= -DBOOST_LOG_DYN_LINK  -I/usr/include -lboost_log  -lboost_log_setup -lboost_filesystem -lboost_system -lboost_thread -lboost_regex -lboost_date_time -lboost_chrono

 boost-bench: boost-bench.cpp
--- a/bench/spdlog-bench-mt.cpp
+++ b/bench/spdlog-bench-mt.cpp
@@ -28,7 +28,7 @@ int main(int argc, char* argv[])
    logger->set_pattern("[%Y-%b-%d %T.%e]: %v");

    std::atomic<int > msg_counter {0};
-    vector<thread> threads;
+    std::vector<thread> threads;

    for (int t = 0; t < thread_count; ++t)
    {
--- a/bench/spdlog-null-async.cpp
+++ b/bench/spdlog-null-async.cpp
@@ -0,0 +1,112 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+//
+// bench.cpp : spdlog benchmarks
+//
+#include <atomic>
+#include <cstdlib> // EXIT_FAILURE
+#include <iostream>
+#include <memory>
+#include <string>
+#include <thread>
+#include "spdlog/spdlog.h"
+#include "spdlog/async_logger.h"
+#include "spdlog/sinks/null_sink.h"
+#include "utils.h"
+
+
+using namespace std;
+using namespace std::chrono;
+using namespace spdlog;
+using namespace spdlog::sinks;
+using namespace utils;
+
+
+
+size_t bench_as(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count);
+
+int main(int argc, char* argv[])
+{
+
+    int queue_size = 1048576;
+    int howmany = 1000000;
+    int threads = 10;
+    int iters = 10;
+
+    try
+    {
+
+        if(argc > 1)
+            howmany = atoi(argv[1]);
+        if (argc > 2)
+            threads =   atoi(argv[2]);
+        if (argc > 3)
+            queue_size = atoi(argv[3]);
+
+       
+        cout << "\n*******************************************************************************\n";
+        cout << "async logging.. " << threads << " threads sharing same logger, " << format(howmany) << " messages " << endl;
+        cout << "*******************************************************************************\n";
+
+        spdlog::set_async_mode(queue_size);
+
+        size_t total_rate = 0;
+
+        for(int i = 0; i < iters; ++i)
+        {
+            //auto as = spdlog::daily_logger_st("as", "logs/daily_async");
+            auto as = spdlog::create<null_sink_st>("async(null-sink)");
+            total_rate+= bench_as(howmany, as, threads);
+            spdlog::drop("async(null-sink)");
+        }
+        std::cout << endl;
+        std::cout << "Avg rate: " << format(total_rate/iters)    << "/sec" <<std::endl;
+        
+    }
+    catch (std::exception &ex)
+    {
+        std::cerr << "Error: " << ex.what() << std::endl;
+        perror("Last error");
+        return EXIT_FAILURE;
+    }
+    return EXIT_SUCCESS;
+}
+
+
+
+//return rate/sec
+size_t bench_as(int howmany, std::shared_ptr<spdlog::logger> log, int thread_count)
+{
+    cout << log->name() << "...\t\t" << flush;
+    std::atomic<int > msg_counter {0};
+    vector<thread> threads;
+    auto start = system_clock::now();
+    for (int t = 0; t < thread_count; ++t)
+    {
+        threads.push_back(std::thread([&]()
+        {
+            for(;;)
+            {
+                int counter = ++msg_counter;
+                if (counter > howmany) break;
+                log->info("Hello logger: msg number {}", counter);
+            }
+        }));
+    }
+
+
+    for(auto &t:threads)
+    {
+        t.join();
+    };
+
+
+    auto delta = system_clock::now() - start;
+    auto delta_d = duration_cast<duration<double>> (delta).count();
+    auto per_sec = size_t(howmany / delta_d);
+    cout << format(per_sec) << "/sec" << endl;
+    return per_sec;
+}
--- a/bench/utils.h
+++ b/bench/utils.h
@@ -0,0 +1,35 @@
+//
+// Copyright(c) 2015 Gabi Melman.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+//
+
+#pragma once
+
+#include <sstream>
+#include <iomanip>
+#include <locale>
+
+namespace utils
+{
+
+template<typename T>
+inline std::string format(const T& value)
+{
+    static std::locale loc("");
+    std::stringstream ss;
+    ss.imbue(loc);
+    ss << value;
+    return ss.str();
+}
+
+template<>
+inline std::string format(const double & value)
+{
+    static std::locale loc("");
+    std::stringstream ss;
+    ss.imbue(loc);
+    ss << std::fixed << std::setprecision(1) << value;
+    return ss.str();
+}
+
+}
--- a/bench/zf_log-bench-mt.cpp
+++ b/bench/zf_log-bench-mt.cpp
@@ -1,56 +0,0 @@
-#include <thread>
-#include <vector>
-#include <atomic>
-#include <cstdlib>
-#include <unistd.h>
-#include <fcntl.h>
-#include <zf_log.c>
-
-const char g_path[] = "logs/zf_log.txt";
-int g_fd;
-
-static void output_callback(zf_log_message *msg)
-{
-    *msg->p = '\n';
-    write(g_fd, msg->buf, msg->p - msg->buf + 1);
-}
-
-using namespace std;
-
-int main(int argc, char* argv[])
-{
-    g_fd = open(g_path, O_APPEND|O_CREAT|O_WRONLY);
-    if (0 > g_fd)
-    {
-        ZF_LOGE_AUX(ZF_LOG_STDERR, "Failed to open log file: %s", g_path);
-        return -1;
-    }
-    zf_log_set_output_callback(ZF_LOG_PUT_STD, output_callback);
-
-    int thread_count = 10;
-    if(argc > 1)
-        thread_count = std::atoi(argv[1]);
-    int howmany = 1000000;
-    std::atomic<int > msg_counter {0};
-    vector<thread> threads;
-
-    for (int t = 0; t < thread_count; ++t)
-    {
-        threads.push_back(std::thread([&]()
-        {
-            while (true)
-            {
-                int counter = ++msg_counter;
-                if (counter > howmany) break;
-                ZF_LOGI("zf_log message #%i: This is some text for your pleasure", counter);
-            }
-        }));
-    }
-
-    for (auto &t:threads)
-    {
-        t.join();
-    };
-    close(g_fd);
-    return 0;
-}
--- a/bench/zf_log-bench.cpp
+++ b/bench/zf_log-bench.cpp
@@ -1,28 +0,0 @@
-#include <stdio.h>
-#include <zf_log.c>
-
-const char g_path[] = "logs/zf_log.txt";
-static FILE *g_f;
-
-static void output_callback(zf_log_message *msg)
-{
-    *msg->p = '\n';
-    fwrite(msg->buf, msg->p - msg->buf + 1, 1, g_f);
-}
-
-int main(int, char* [])
-{
-    g_f = fopen(g_path, "wb");
-    if (!g_f)
-    {
-        ZF_LOGE_AUX(ZF_LOG_STDERR, "Failed to open log file: %s", g_path);
-        return -1;
-    }
-    zf_log_set_output_callback(ZF_LOG_PUT_STD, output_callback);
-
-    const int howmany = 1000000;
-    for(int i  = 0 ; i < howmany; ++i)
-        ZF_LOGI("zf_log message #%i: This is some text for your pleasure", i);
-    fclose(g_f);
-    return 0;
-}
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -40,6 +40,9 @@ target_link_libraries(example spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT})
 add_executable(benchmark bench.cpp)
 target_link_libraries(benchmark spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT})

+add_executable(multisink multisink.cpp)
+target_link_libraries(multisink spdlog::spdlog ${CMAKE_THREAD_LIBS_INIT})
+
 enable_testing()
 file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/logs")
 add_test(NAME RunExample COMMAND example)
--- a/example/bench.cpp
+++ b/example/bench.cpp
@@ -35,7 +35,6 @@ int main(int argc, char* argv[])
    int queue_size = 1048576;
    int howmany = 1000000;
    int threads = 10;
-    bool auto_flush = false;
    int file_size = 30 * 1024 * 1024;
    int rotating_files = 5;

@@ -51,29 +50,29 @@ int main(int argc, char* argv[])


        cout << "*******************************************************************************\n";
-        cout << "Single thread, " << format(howmany)  << " iterations, auto flush=" << auto_flush << endl;
+        cout << "Single thread, " << format(howmany)  << " iterations" << endl;
        cout << "*******************************************************************************\n";

-        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st", file_size, rotating_files, auto_flush);
+        auto rotating_st = spdlog::rotating_logger_st("rotating_st", "logs/rotating_st", file_size, rotating_files);
        bench(howmany, rotating_st);
-        auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st", auto_flush);
+        auto daily_st = spdlog::daily_logger_st("daily_st", "logs/daily_st");
        bench(howmany, daily_st);
        bench(howmany, spdlog::create<null_sink_st>("null_st"));

        cout << "\n*******************************************************************************\n";
-        cout << threads << " threads sharing same logger, " << format(howmany)  << " iterations, auto_flush=" << auto_flush << endl;
+        cout << threads << " threads sharing same logger, " << format(howmany)  << " iterations" << endl;
        cout << "*******************************************************************************\n";

-        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt", file_size, rotating_files, auto_flush);
+        auto rotating_mt = spdlog::rotating_logger_mt("rotating_mt", "logs/rotating_mt", file_size, rotating_files);
        bench_mt(howmany, rotating_mt, threads);


-        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt", auto_flush);
+        auto daily_mt = spdlog::daily_logger_mt("daily_mt", "logs/daily_mt");
        bench_mt(howmany, daily_mt, threads);
        bench(howmany, spdlog::create<null_sink_st>("null_mt"));

        cout << "\n*******************************************************************************\n";
-        cout << "async logging.. " << threads << " threads sharing same logger, " << format(howmany) << " iterations, auto_flush=" << auto_flush << endl;
+        cout << "async logging.. " << threads << " threads sharing same logger, " << format(howmany) << " iterations " << endl;
        cout << "*******************************************************************************\n";


@@ -81,7 +80,7 @@ int main(int argc, char* argv[])

        for(int i = 0; i < 3; ++i)
        {
-            auto as = spdlog::daily_logger_st("as", "logs/daily_async", auto_flush);
+            auto as = spdlog::daily_logger_st("as", "logs/daily_async");
            bench_mt(howmany, as, threads);
            spdlog::drop("as");
        }
--- a/example/example.cpp
+++ b/example/example.cpp
@@ -5,15 +5,17 @@
 //
 // spdlog usage example
 //
+//
 #include "spdlog/spdlog.h"

-#include <cstdlib> // EXIT_FAILURE
 #include <iostream>
 #include <memory>

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

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

        // Formatting examples
        console->warn("Easy padding in numbers like {:08d}", 12);
@@ -47,7 +49,6 @@ int main(int, char*[])
        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)
@@ -55,13 +56,14 @@ int main(int, char*[])

        // 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);
+        // trigger flush if the log severity is error or higher
+        daily_logger->flush_on(spd::level::err);
        daily_logger->info(123.44);

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

-
        // Compile time debug or trace macros.
        // Enabled #ifdef SPDLOG_DEBUG_ON or #ifdef SPDLOG_TRACE_ON
        SPDLOG_TRACE(console, "Enabled only #ifdef SPDLOG_TRACE_ON..{} ,{}", 1, 3.23);
@@ -71,42 +73,62 @@ 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..
+        // android example. compile with NDK
+        android_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;
-        return EXIT_FAILURE;
+        std::cout << "Log init failed: " << ex.what() << std::endl;
+        return 1;
    }
-    return EXIT_SUCCESS;
 }

-
 void async_example()
 {
    size_t q_size = 4096; //queue size must be power of 2
    spdlog::set_async_mode(q_size);
    auto async_file = spd::daily_logger_st("async_file_logger", "logs/async_log.txt");
+
    for (int i = 0; i < 100; ++i)
        async_file->info("Async message #{}", i);
 }

-//syslog example (linux/osx only)
+//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
+}
+
+// Android example
+void android_example()
+{
+#if defined(__ANDROID__)
+    std::string tag = "spdlog-android";
+    auto android_logger = spd::android_logger("android", tag);
+    android_logger->critical("Use \"adb shell logcat\" to view this message.");
 #endif
 }

@@ -127,3 +149,15 @@ 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);
+}
--- a/example/jni/Android.mk
+++ b/example/jni/Android.mk
@@ -0,0 +1,15 @@
+# Setup a project
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE := example
+LOCAL_SRC_FILES := example.cpp
+LOCAL_CPPFLAGS += -Wall -Wshadow -Wextra -pedantic -std=c++11 -fPIE -pie
+LOCAL_LDFLAGS +=  -fPIE -pie
+
+# Add exception support and set path for spdlog's headers
+LOCAL_CPPFLAGS += -fexceptions -I../include
+# Use android's log library
+LOCAL_LDFLAGS += -llog
+
+include $(BUILD_EXECUTABLE)
--- a/example/jni/Application.mk
+++ b/example/jni/Application.mk
@@ -0,0 +1,2 @@
+# Exceptions are used in spdlog. Link to an exception-ready C++ runtime.
+APP_STL = gnustl_static
--- a/example/jni/example.cpp
+++ b/example/jni/example.cpp
@@ -0,0 +1 @@
+../example.cpp
--- a/example/multisink.cpp
+++ b/example/multisink.cpp
@@ -0,0 +1,47 @@
+#include "spdlog/spdlog.h"
+
+#include <iostream>
+#include <memory>
+
+namespace spd = spdlog;
+int main(int, char*[])
+{
+    bool enable_debug = true;
+    try
+    {
+        // This other example use a single logger with multiple sinks.
+        // This means that the same log_msg is forwarded to multiple sinks;
+        // Each sink can have it's own log level and a message will be logged.
+        std::vector<spdlog::sink_ptr> sinks;
+        sinks.push_back( std::make_shared<spdlog::sinks::stdout_sink_mt>() );
+        sinks.push_back( std::make_shared<spdlog::sinks::simple_file_sink_mt>("./log_regular_file.txt") );
+        sinks.push_back( std::make_shared<spdlog::sinks::simple_file_sink_mt>("./log_debug_file.txt") );
+
+        spdlog::logger console_multisink("multisink",  sinks.begin(), sinks.end() );
+        console_multisink.set_level( spdlog::level::warn);
+
+        sinks[0]->set_level( spdlog::level::trace);  // console. Allow everything.  Default value
+        sinks[1]->set_level( spdlog::level::trace);  //  regular file. Allow everything.  Default value
+        sinks[2]->set_level( spdlog::level::off);    //  regular file. Ignore everything.
+
+        console_multisink.warn("warn: will print only on console and regular file");
+
+        if( enable_debug )
+        {
+            console_multisink.set_level( spdlog::level::debug); // level of the logger
+            sinks[1]->set_level( spdlog::level::debug);  // regular file
+            sinks[2]->set_level( spdlog::level::debug);  // debug file
+        }
+        console_multisink.debug("Debug: you should see this on console and both files");
+
+        // Release and close all loggers
+        spdlog::drop_all();
+    }
+    // Exceptions will only be thrown upon failed logger or sink construction (not during logging)
+    catch (const spd::spdlog_ex& ex)
+    {
+        std::cout << "Log init failed: " << ex.what() << std::endl;
+        return 1;
+    }
+}
+
--- a/include/spdlog/async_logger.h
+++ b/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;
--- a/include/spdlog/common.h
+++ b/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
--- a/include/spdlog/details/async_log_helper.h
+++ b/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(),
@@ -132,7 +133,7 @@ public:

    void set_formatter(formatter_ptr);

-    void flush();
+    void flush(bool wait_for_q);


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

 }

-inline void spdlog::details::async_log_helper::flush()
+// optionally wait for the queue be empty and request flush from the sinks
+inline void spdlog::details::async_log_helper::flush(bool wait_for_q)
 {
    push_msg(async_msg(async_msg_type::flush));
+    if(wait_for_q)
+        wait_empty_q(); //return only make after the above flush message was processed
 }

 inline void spdlog::details::async_log_helper::worker_loop()
@@ -263,13 +267,13 @@ inline void spdlog::details::async_log_helper::worker_loop()
        while(process_next_msg(last_pop, last_flush));
        if (_worker_teardown_cb) _worker_teardown_cb();
    }
-    catch (const std::exception& ex)
+    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");
    }
 }

@@ -300,7 +304,12 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_
            incoming_async_msg.fill_log_msg(incoming_log_msg);
            _formatter->format(incoming_log_msg);
            for (auto &s : _sinks)
-                s->log(incoming_log_msg);
+            {
+                if(s->should_log( incoming_log_msg.level))
+                {
+                    s->log(incoming_log_msg);
+                }
+            }
        }
        return true;
    }
@@ -313,7 +322,6 @@ inline bool spdlog::details::async_log_helper::process_next_msg(log_clock::time_
        handle_flush_interval(now, last_flush);
        sleep_or_yield(now, last_pop);
        return !_terminate_requested;
-
    }
 }

@@ -362,14 +370,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
-inline void spdlog::details::async_log_helper::throw_if_bad_worker()
+// wait for the queue to be empty
+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);
-        throw *ex;
+        sleep_or_yield(details::os::now(), last_op);
    }
+
 }


@@ -378,3 +387,4 @@ inline void spdlog::details::async_log_helper::throw_if_bad_worker()



+
--- a/include/spdlog/details/async_logger_impl.h
+++ b/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))
 {
 }

@@ -54,8 +54,7 @@ inline spdlog::async_logger::async_logger(const std::string& logger_name,

 inline void spdlog::async_logger::flush()
 {
-
-    _async_log_helper->flush();
+    _async_log_helper->flush(true);
 }

 inline void spdlog::async_logger::_set_formatter(spdlog::formatter_ptr msg_formatter)
@@ -73,5 +72,18 @@ inline void spdlog::async_logger::_set_pattern(const std::string& pattern)

 inline void spdlog::async_logger::_sink_it(details::log_msg& msg)
 {
-    _async_log_helper->log(msg);
+    try
+    {
+        _async_log_helper->log(msg);
+        if (_should_flush_on(msg))
+            _async_log_helper->flush(false); // do async flush
+    }
+    catch (const std::exception &ex)
+    {
+        _err_handler(ex.what());
+    }
+    catch (...)
+    {
+        _err_handler("Unknown exception");
+    }
 }
--- a/include/spdlog/details/file_helper.h
+++ b/include/spdlog/details/file_helper.h
@@ -31,9 +31,8 @@ public:
    const int open_tries = 5;
    const int open_interval = 10;

-    explicit file_helper(bool force_flush) :
-        _fd(nullptr),
-        _force_flush(force_flush)
+    explicit file_helper() :
+        _fd(nullptr)        
    {}

    file_helper(const file_helper&) = delete;
@@ -90,17 +89,14 @@ public:
        size_t msg_size = msg.formatted.size();
        auto data = msg.formatted.data();
        if (std::fwrite(data, 1, msg_size, _fd) != msg_size)
-            throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno);
-
-        if (_force_flush)
-            std::fflush(_fd);
+            throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno);        
    }

    size_t size()
    {
        if (!_fd)
            throw spdlog_ex("Cannot use size() on closed file " + os::filename_to_str(_filename));
-		return os::filesize(_fd); 
+        return os::filesize(_fd);
    }

    const filename_t& filename() const
@@ -116,8 +112,7 @@ public:

 private:
    FILE* _fd;
-    filename_t _filename;
-    bool _force_flush;
+    filename_t _filename;    
 };
 }
 }
--- a/include/spdlog/details/logger_impl.h
+++ b/include/spdlog/details/logger_impl.h
@@ -6,35 +6,42 @@
 #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>
-inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end) :
+inline spdlog::logger::logger(const std::string& logger_name, const It& begin, const It& end):
    _name(logger_name),
    _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()) {}
+inline spdlog::logger::logger(const std::string& logger_name, sinks_init_list sinks_list):
+    logger(logger_name, sinks_list.begin(), sinks_list.end())
+{}


 // ctor with single sink
-inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink) :
+inline spdlog::logger::logger(const std::string& logger_name, spdlog::sink_ptr single_sink):
    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...);
+        _sink_it(log_msg);
    }
-    catch (fmt::FormatError &ex)
+    catch (const std::exception &ex)
    {
-        throw spdlog::spdlog_ex(std::string("format error in \"") + fmt + "\": " + ex.what());
+        _err_handler(ex.what());
+    }
+    catch (...)
+    {
+        _err_handler("Unknown exception");
    }
-
-    _sink_it(log_msg);
-
 }

 template <typename... Args>
 inline void spdlog::logger::log(level::level_enum lvl, const char* msg)
 {
    if (!should_log(lvl)) return;
-
-    details::log_msg log_msg(&_name, lvl);
-    log_msg.raw << msg;
-    _sink_it(log_msg);
+    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;
-
-    details::log_msg log_msg(&_name, lvl);
-    log_msg.raw << msg;
-    _sink_it(log_msg);
-
+    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);
@@ -207,10 +246,14 @@ inline void spdlog::logger::_sink_it(details::log_msg& msg)
 {
    _formatter->format(msg);
    for (auto &sink : _sinks)
-        sink->log(msg);
+    {
+        if( sink->should_log( msg.level))
+        {
+            sink->log(msg);
+        }
+    }

-    const auto flush_level = _flush_level.load(std::memory_order_relaxed);
-    if (msg.level >= flush_level)
+    if(_should_flush_on(msg))
        flush();
 }

@@ -228,3 +271,23 @@ 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;
+}
+
+inline bool spdlog::logger::_should_flush_on(const details::log_msg &msg)
+{
+    const auto flush_level = _flush_level.load(std::memory_order_relaxed);
+    return (msg.level >= flush_level) && (msg.level != level::off);
+}
--- a/include/spdlog/details/mpmc_bounded_q.h
+++ b/include/spdlog/details/mpmc_bounded_q.h
@@ -60,8 +60,9 @@ public:

    using item_type = T;
    mpmc_bounded_queue(size_t buffer_size)
-        : buffer_(new cell_t [buffer_size]),
-          buffer_mask_(buffer_size - 1)
+        :max_size_(buffer_size),
+         buffer_(new cell_t [buffer_size]),
+         buffer_mask_(buffer_size - 1)
    {
        //queue size must be power of two
        if(!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
@@ -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&);
-    void operator = (mpmc_bounded_queue const&);
+    mpmc_bounded_queue(mpmc_bounded_queue const&) = delete;
+    void operator= (mpmc_bounded_queue const&) = delete;
 };

 } // ns details
--- a/include/spdlog/details/os.h
+++ b/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
@@ -192,35 +194,35 @@ inline bool file_exists(const filename_t& filename)
 //Return file size according to open FILE* object
 inline size_t filesize(FILE *f)
 {
-	if (f == nullptr)
-		throw spdlog_ex("Failed getting file size. fd is null");
+    if (f == nullptr)
+        throw spdlog_ex("Failed getting file size. fd is null");
 #ifdef _WIN32
-	int fd = _fileno(f);
-#if _WIN64 //64 bits		
-	struct _stat64 st;	
-	if (_fstat64(fd, &st) == 0)
-		return st.st_size;
-			
-#else //windows 32 bits		
-	struct _stat st;
-	if (_fstat(fd, &st) == 0)
-		return st.st_size;
+    int fd = _fileno(f);
+#if _WIN64 //64 bits
+    struct _stat64 st;
+    if (_fstat64(fd, &st) == 0)
+        return st.st_size;
+
+#else //windows 32 bits
+    struct _stat st;
+    if (_fstat(fd, &st) == 0)
+        return st.st_size;
 #endif

 #else // unix
-	int fd = fileno(f);
-	//64 bits(but not in osx, where fstat64 is deprecated)
-	#if !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__)) 
-	struct stat64 st;
-	if (fstat64(fd, &st) == 0)
-		return st.st_size;	
-#else // unix 32 bits or osx	
-	struct stat st;
-	if (fstat(fd, &st) == 0)
-		return st.st_size;	
+    int fd = fileno(f);
+    //64 bits(but not in osx, where fstat64 is deprecated)
+#if !defined(__FreeBSD__) && !defined(__APPLE__) && (defined(__x86_64__) || defined(__ppc64__))
+    struct stat64 st;
+    if (fstat64(fd, &st) == 0)
+        return st.st_size;
+#else // unix 32 bits or osx
+    struct stat st;
+    if (fstat(fd, &st) == 0)
+        return st.st_size;
 #endif
 #endif
-	throw spdlog_ex("Failed getting file size from fd", errno);
+    throw spdlog_ex("Failed getting file size from fd", errno);
 }


@@ -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,9 @@ 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__) || defined(ANDROID) || \
+      ((_POSIX_C_SOURCE >= 200112L) && ! _GNU_SOURCE) // posix version
+
    if (strerror_r(err_num, buf, buf_size) == 0)
        return std::string(buf);
    else
@@ -313,5 +358,3 @@ inline std::string errno_str(int err_num)
 } //os
 } //details
 } //spdlog
-
-
--- a/include/spdlog/details/pattern_formatter_impl.h
+++ b/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;
 };

@@ -35,7 +36,7 @@ public:
 ///////////////////////////////////////////////////////////////////////
 namespace
 {
-class name_formatter :public flag_formatter
+class name_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm&) override
    {
@@ -45,7 +46,7 @@ class name_formatter :public flag_formatter
 }

 // log level appender
-class level_formatter :public flag_formatter
+class level_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm&) override
    {
@@ -54,7 +55,7 @@ class level_formatter :public flag_formatter
 };

 // short log level appender
-class short_level_formatter :public flag_formatter
+class short_level_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm&) override
    {
@@ -78,7 +79,7 @@ static int to12h(const tm& t)

 //Abbreviated weekday name
 static const std::string days[] { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
-class a_formatter :public flag_formatter
+class a_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -88,7 +89,7 @@ class a_formatter :public flag_formatter

 //Full weekday name
 static const std::string full_days[] { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
-class A_formatter :public flag_formatter
+class A_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -98,17 +99,17 @@ class A_formatter :public flag_formatter

 //Abbreviated month
 static const std::string  months[] { "Jan", "Feb", "Mar", "Apr", "May", "June", "July", "Aug", "Sept", "Oct", "Nov", "Dec" };
-class b_formatter :public flag_formatter
+class b_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
-        msg.formatted<< months[tm_time.tm_mon];
+        msg.formatted << months[tm_time.tm_mon];
    }
 };

 //Full month name
 static const std::string full_months[] { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
-class B_formatter :public flag_formatter
+class B_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -133,7 +134,7 @@ static fmt::MemoryWriter& pad_n_join(fmt::MemoryWriter& w, int v1, int v2, int v


 //Date and time representation (Thu Aug 23 15:35:46 2014)
-class c_formatter :public flag_formatter
+class c_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -144,7 +145,7 @@ class c_formatter :public flag_formatter


 // year - 2 digit
-class C_formatter :public flag_formatter
+class C_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -155,7 +156,7 @@ class C_formatter :public flag_formatter


 // Short MM/DD/YY date, equivalent to %m/%d/%y 08/23/01
-class D_formatter :public flag_formatter
+class D_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -165,7 +166,7 @@ class D_formatter :public flag_formatter


 // year - 4 digit
-class Y_formatter :public flag_formatter
+class Y_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -174,7 +175,7 @@ class Y_formatter :public flag_formatter
 };

 // month 1-12
-class m_formatter :public flag_formatter
+class m_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -183,7 +184,7 @@ class m_formatter :public flag_formatter
 };

 // day of month 1-31
-class d_formatter :public flag_formatter
+class d_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -192,7 +193,7 @@ class d_formatter :public flag_formatter
 };

 // hours in 24 format  0-23
-class H_formatter :public flag_formatter
+class H_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -201,7 +202,7 @@ class H_formatter :public flag_formatter
 };

 // hours in 12 format  1-12
-class I_formatter :public flag_formatter
+class I_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -210,7 +211,7 @@ class I_formatter :public flag_formatter
 };

 // minutes 0-59
-class M_formatter :public flag_formatter
+class M_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -219,7 +220,7 @@ class M_formatter :public flag_formatter
 };

 // seconds 0-59
-class S_formatter :public flag_formatter
+class S_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -228,7 +229,7 @@ class S_formatter :public flag_formatter
 };

 // milliseconds
-class e_formatter :public flag_formatter
+class e_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm&) override
    {
@@ -239,7 +240,7 @@ class e_formatter :public flag_formatter
 };

 // microseconds
-class f_formatter :public flag_formatter
+class f_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm&) override
    {
@@ -250,7 +251,7 @@ class f_formatter :public flag_formatter
 };

 // nanoseconds
-class F_formatter :public flag_formatter
+class F_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm&) override
    {
@@ -261,7 +262,7 @@ class F_formatter :public flag_formatter
 };

 // AM/PM
-class p_formatter :public flag_formatter
+class p_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -271,7 +272,7 @@ class p_formatter :public flag_formatter


 // 12 hour clock 02:55:02 pm
-class r_formatter :public flag_formatter
+class r_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -280,7 +281,7 @@ class r_formatter :public flag_formatter
 };

 // 24-hour HH:MM time, equivalent to %H:%M
-class R_formatter :public flag_formatter
+class R_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -289,7 +290,7 @@ class R_formatter :public flag_formatter
 };

 // ISO 8601 time format (HH:MM:SS), equivalent to %H:%M:%S
-class T_formatter :public flag_formatter
+class T_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -299,12 +300,13 @@ class T_formatter :public flag_formatter


 // ISO 8601 offset from UTC in timezone (+-HH:MM)
-class z_formatter :public flag_formatter
+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 << '+';
-        }
+        msg.formatted << sign;
        pad_n_join(msg.formatted, h, m, ':');
    }
 private:
@@ -347,7 +357,7 @@ private:


 //Thread id
-class t_formatter :public flag_formatter
+class t_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm&) override
    {
@@ -356,7 +366,7 @@ class t_formatter :public flag_formatter
 };


-class v_formatter :public flag_formatter
+class v_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm&) override
    {
@@ -364,10 +374,10 @@ class v_formatter :public flag_formatter
    }
 };

-class ch_formatter :public flag_formatter
+class ch_formatter:public flag_formatter
 {
 public:
-    explicit ch_formatter(char ch) : _ch(ch)
+    explicit ch_formatter(char ch): _ch(ch)
    {}
    void format(details::log_msg& msg, const std::tm&) override
    {
@@ -379,7 +389,7 @@ private:


 //aggregate user chars to display as is
-class aggregate_formatter :public flag_formatter
+class aggregate_formatter:public flag_formatter
 {
 public:
    aggregate_formatter()
@@ -398,7 +408,7 @@ private:

 // Full info formatter
 // pattern: [%Y-%m-%d %H:%M:%S.%e] [%n] [%l] %v
-class full_formatter :public flag_formatter
+class full_formatter:public flag_formatter
 {
    void format(details::log_msg& msg, const std::tm& tm_time) override
    {
@@ -429,7 +439,7 @@ 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') << "] ";

-//no datetime needed
+        //no datetime needed
 #else
        (void)tm_time;
 #endif
@@ -499,101 +509,101 @@ inline void spdlog::pattern_formatter::handle_flag(char flag)
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::short_level_formatter()));
        break;

-    case('t') :
+    case('t'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::t_formatter()));
        break;

-    case('v') :
+    case('v'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::v_formatter()));
        break;

-    case('a') :
+    case('a'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::a_formatter()));
        break;

-    case('A') :
+    case('A'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::A_formatter()));
        break;

-    case('b') :
-    case('h') :
+    case('b'):
+    case('h'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::b_formatter()));
        break;

-    case('B') :
+    case('B'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::B_formatter()));
        break;
-    case('c') :
+    case('c'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::c_formatter()));
        break;

-    case('C') :
+    case('C'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::C_formatter()));
        break;

-    case('Y') :
+    case('Y'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::Y_formatter()));
        break;

-    case('D') :
-    case('x') :
+    case('D'):
+    case('x'):

        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::D_formatter()));
        break;

-    case('m') :
+    case('m'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::m_formatter()));
        break;

-    case('d') :
+    case('d'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::d_formatter()));
        break;

-    case('H') :
+    case('H'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::H_formatter()));
        break;

-    case('I') :
+    case('I'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::I_formatter()));
        break;

-    case('M') :
+    case('M'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::M_formatter()));
        break;

-    case('S') :
+    case('S'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::S_formatter()));
        break;

-    case('e') :
+    case('e'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::e_formatter()));
        break;

-    case('f') :
+    case('f'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::f_formatter()));
        break;
-    case('F') :
+    case('F'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::F_formatter()));
        break;

-    case('p') :
+    case('p'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::p_formatter()));
        break;

-    case('r') :
+    case('r'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::r_formatter()));
        break;

-    case('R') :
+    case('R'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::R_formatter()));
        break;

-    case('T') :
-    case('X') :
+    case('T'):
+    case('X'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::T_formatter()));
        break;

-    case('z') :
+    case('z'):
        _formatters.push_back(std::unique_ptr<details::flag_formatter>(new details::z_formatter()));
        break;

@@ -611,22 +621,16 @@ 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));
+    auto tm_time = details::os::localtime(log_clock::to_time_t(msg.time));
 #else
-        std::tm tm_time;
+    std::tm tm_time;
 #endif
-        for (auto &f : _formatters)
-        {
-            f->format(msg, tm_time);
-        }
-        //write eol
-        msg.formatted.write(details::os::eol, details::os::eol_size);
-    }
-    catch(const fmt::FormatError& e)
+    for (auto &f : _formatters)
    {
-        throw spdlog_ex(fmt::format("formatting error while processing format string: {}", e.what()));
+        f->format(msg, tm_time);
    }
+    //write eol
+    msg.formatted.write(details::os::eol, details::os::eol_size);
 }
--- a/include/spdlog/details/registry.h
+++ b/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;
--- a/include/spdlog/details/spdlog_impl.h
+++ b/include/spdlog/details/spdlog_impl.h
@@ -14,6 +14,7 @@
 #include <spdlog/sinks/stdout_sinks.h>
 #include <spdlog/sinks/syslog_sink.h>
 #include <spdlog/sinks/ansicolor_sink.h>
+#include <spdlog/sinks/android_sink.h>

 #include <chrono>
 #include <functional>
@@ -36,36 +37,36 @@ 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 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, 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 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, truncate);
 }

 // Create multi/single threaded rotating file logger
-inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files, bool force_flush)
+inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files)
 {
-    return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files, force_flush);
+    return create<spdlog::sinks::rotating_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files);
 }

-inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files, bool force_flush)
+inline std::shared_ptr<spdlog::logger> spdlog::rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files)
 {
-    return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files, force_flush);
+    return create<spdlog::sinks::rotating_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files);
 }

 // 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 filename_t& filename, int hour, int minute, bool force_flush)
+inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour, int minute)
 {
-    return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute, force_flush);
+    return create<spdlog::sinks::daily_file_sink_mt>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute);
 }

-inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour, int minute, bool force_flush)
+inline std::shared_ptr<spdlog::logger> spdlog::daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour, int minute)
 {
-    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute, force_flush);
+    return create<spdlog::sinks::daily_file_sink_st>(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute);
 }

 // Create stdout/stderr loggers (with optinal color support)
@@ -96,7 +97,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)
 {
@@ -104,6 +105,13 @@ inline std::shared_ptr<spdlog::logger> spdlog::syslog_logger(const std::string&
 }
 #endif

+#if defined(__ANDROID__)
+inline std::shared_ptr<spdlog::logger> spdlog::android_logger(const std::string& logger_name, const std::string& tag)
+{
+    return create<spdlog::sinks::android_sink>(logger_name, tag);
+}
+#endif
+
 // Create and register a logger a single sink
 inline std::shared_ptr<spdlog::logger> spdlog::create(const std::string& logger_name, const spdlog::sink_ptr& sink)
 {
@@ -147,6 +155,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 +171,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();
--- a/include/spdlog/fmt/bundled/format.cc
+++ b/include/spdlog/fmt/bundled/format.cc
@@ -25,9 +25,9 @@
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

- // Commented out by spdlog to use header only
- // #include "fmt/format.h"
- // #include "fmt/printf.h"
+// Commented out by spdlog to use header only
+// #include "fmt/format.h"
+// #include "fmt/printf.h"

 #include <string.h>

--- a/include/spdlog/fmt/bundled/format.h
+++ b/include/spdlog/fmt/bundled/format.h
@@ -1308,19 +1308,25 @@ struct Conditional<false, T, F>
 };

 // For bcc32 which doesn't understand ! in template arguments.
-template<bool>
+template <bool>
 struct Not
 {
    enum { value = 0 };
 };

-template<>
+template <>
 struct Not<false>
 {
    enum { value = 1 };
 };

-template<typename T, T> struct LConvCheck
+template <typename T>
+struct False
+{
+    enum { value = 0 };
+};
+
+template <typename T, T> struct LConvCheck
 {
    LConvCheck(int) {}
 };
@@ -1340,6 +1346,36 @@ inline fmt::StringRef thousands_sep(...)
    return "";
 }

+#define FMT_CONCAT(a, b) a##b
+
+#if FMT_GCC_VERSION >= 407
+# define FMT_UNUSED __attribute__((unused))
+#else
+# define FMT_UNUSED
+#endif
+
+#ifndef FMT_USE_STATIC_ASSERT
+# define FMT_USE_STATIC_ASSERT 0
+#endif
+
+#if FMT_USE_STATIC_ASSERT || FMT_HAS_FEATURE(cxx_static_assert) || \
+  (FMT_GCC_VERSION >= 403 && FMT_HAS_GXX_CXX11) || _MSC_VER >= 1600
+# define FMT_STATIC_ASSERT(cond, message) static_assert(cond, message)
+#else
+# define FMT_CONCAT_(a, b) FMT_CONCAT(a, b)
+# define FMT_STATIC_ASSERT(cond, message) \
+  typedef int FMT_CONCAT_(Assert, __LINE__)[(cond) ? 1 : -1] FMT_UNUSED
+#endif
+
+template <typename Formatter, typename Char, typename T>
+void format_arg(Formatter &, const Char *, const T &)
+{
+    FMT_STATIC_ASSERT(False<T>::value,
+                      "Cannot format argument. To enable the use of ostream "
+                      "operator<< include fmt/ostream.h. Otherwise provide "
+                      "an overload of format_arg.");
+}
+
 // Makes an Arg object from any type.
 template <typename Formatter>
 class MakeValue : public Arg
@@ -1387,9 +1423,9 @@ private:
    static void format_custom_arg(
        void *formatter, const void *arg, void *format_str_ptr)
    {
-        format(*static_cast<Formatter*>(formatter),
-               *static_cast<const Char**>(format_str_ptr),
-               *static_cast<const T*>(arg));
+        format_arg(*static_cast<Formatter*>(formatter),
+                   *static_cast<const Char**>(format_str_ptr),
+                   *static_cast<const T*>(arg));
    }

 public:
@@ -1461,7 +1497,9 @@ public:

    FMT_MAKE_VALUE(char *, string.value, CSTRING)
    FMT_MAKE_VALUE(const char *, string.value, CSTRING)
+    FMT_MAKE_VALUE(signed char *, sstring.value, CSTRING)
    FMT_MAKE_VALUE(const signed char *, sstring.value, CSTRING)
+    FMT_MAKE_VALUE(unsigned char *, ustring.value, CSTRING)
    FMT_MAKE_VALUE(const unsigned char *, ustring.value, CSTRING)
    FMT_MAKE_STR_VALUE(const std::string &, STRING)
    FMT_MAKE_STR_VALUE(StringRef, STRING)
@@ -3260,7 +3298,10 @@ void BasicWriter<Char>::write_int(T value, Spec spec)
    case 'n':
    {
        unsigned num_digits = internal::count_digits(abs_value);
-        fmt::StringRef sep = internal::thousands_sep(std::localeconv());
+        fmt::StringRef sep = "";
+#ifndef ANDROID
+        sep = internal::thousands_sep(std::localeconv());
+#endif
        unsigned size = static_cast<unsigned>(
                            num_digits + sep.size() * ((num_digits - 1) / 3));
        CharPtr p = prepare_int_buffer(size, spec, prefix, prefix_size) + 1;
@@ -3871,7 +3912,6 @@ void arg(WStringRef, const internal::NamedArg<Char>&) FMT_DELETED_OR_UNDEFINED;
 #define FMT_ARG_N(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
 #define FMT_RSEQ_N() 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0

-#define FMT_CONCAT(a, b) a##b
 #define FMT_FOR_EACH_(N, f, ...) \
  FMT_EXPAND(FMT_CONCAT(FMT_FOR_EACH, N)(f, __VA_ARGS__))
 #define FMT_FOR_EACH(f, ...) \
--- a/include/spdlog/fmt/bundled/ostream.cc
+++ b/include/spdlog/fmt/bundled/ostream.cc
@@ -7,15 +7,13 @@
 For the license information refer to format.h.
 */

- // Commented out by spdlog to use header only
- // #include "fmt/ostream.h"
- // #include "fmt/printf.h"
+// Commented out by spdlog to use header only
+// #include "fmt/ostream.h"

 namespace fmt {

-namespace {
-// Write the content of w to os.
-void write(std::ostream &os, Writer &w) {
+namespace internal {
+FMT_FUNC void write(std::ostream &os, Writer &w) {
  const char *data = w.data();
  typedef internal::MakeUnsigned<std::streamsize>::Type UnsignedStreamSize;
  UnsignedStreamSize size = w.size();
@@ -33,13 +31,6 @@ void write(std::ostream &os, Writer &w) {
 FMT_FUNC void print(std::ostream &os, CStringRef format_str, ArgList args) {
  MemoryWriter w;
  w.write(format_str, args);
-  write(os, w);
-}
-
-FMT_FUNC int fprintf(std::ostream &os, CStringRef format, ArgList args) {
-  MemoryWriter w;
-  printf(w, format, args);
-  write(os, w);
-  return static_cast<int>(w.size());
+  internal::write(os, w);
 }
 }  // namespace fmt
--- a/include/spdlog/fmt/bundled/ostream.h
+++ b/include/spdlog/fmt/bundled/ostream.h
@@ -77,12 +77,15 @@ struct ConvertToIntImpl<T, true>
        value = sizeof(convert(get<DummyStream>() << get<T>())) == sizeof(No)
    };
 };
+
+// Write the content of w to os.
+void write(std::ostream &os, Writer &w);
 }  // namespace internal

 // Formats a value.
 template <typename Char, typename ArgFormatter, typename T>
-void format(BasicFormatter<Char, ArgFormatter> &f,
-            const Char *&format_str, const T &value)
+void format_arg(BasicFormatter<Char, ArgFormatter> &f,
+                const Char *&format_str, const T &value)
 {
    internal::MemoryBuffer<Char, internal::INLINE_BUFFER_SIZE> buffer;

@@ -106,18 +109,6 @@ void format(BasicFormatter<Char, ArgFormatter> &f,
 */
 FMT_API void print(std::ostream &os, CStringRef format_str, ArgList args);
 FMT_VARIADIC(void, print, std::ostream &, CStringRef)
-
-/**
-  \rst
-  Prints formatted data to the stream *os*.
-
-  **Example**::
-
-    fprintf(cerr, "Don't %s!", "panic");
-  \endrst
- */
-FMT_API int fprintf(std::ostream &os, CStringRef format_str, ArgList args);
-FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)
 }  // namespace fmt

 #ifdef FMT_HEADER_ONLY
--- a/include/spdlog/fmt/bundled/printf.h
+++ b/include/spdlog/fmt/bundled/printf.h
@@ -13,7 +13,7 @@
 #include <algorithm>  // std::fill_n
 #include <limits>     // std::numeric_limits

-#include "fmt/format.h"
+#include "fmt/ostream.h"

 namespace fmt
 {
@@ -619,6 +619,24 @@ inline int printf(CStringRef format, ArgList args)
    return fprintf(stdout, format, args);
 }
 FMT_VARIADIC(int, printf, CStringRef)
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fprintf(cerr, "Don't %s!", "panic");
+  \endrst
+ */
+inline int fprintf(std::ostream &os, CStringRef format_str, ArgList args)
+{
+    MemoryWriter w;
+    printf(w, format_str, args);
+    internal::write(os, w);
+    return static_cast<int>(w.size());
+}
+FMT_VARIADIC(int, fprintf, std::ostream &, CStringRef)
 }  // namespace fmt

 #endif  // FMT_PRINTF_H_
--- a/include/spdlog/logger.h
+++ b/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,8 +59,13 @@ 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();

 protected:
@@ -70,11 +73,19 @@ 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);
+
+    // return true if the given message level should trigger a flush
+    bool _should_flush_on(const details::log_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;
 };
 }

--- a/include/spdlog/sinks/android_sink.h
+++ b/include/spdlog/sinks/android_sink.h
@@ -7,51 +7,43 @@

 #if defined(__ANDROID__)

-#include <spdlog/sinks/base_sink.h>
-#include <spdlog/details/null_mutex.h>
-
-#include <android/log.h>
+#include <spdlog/sinks/sink.h>

 #include <mutex>
 #include <string>
+#include <android/log.h>

 namespace spdlog
 {
 namespace sinks
 {
+
 /*
 * Android sink (logging using __android_log_write)
+* __android_log_write is thread-safe. No lock is needed.
 */
-template<class Mutex>
-class base_android_sink : public base_sink < Mutex >
+class android_sink : public sink
 {
 public:
-    explicit base_android_sink(std::string tag="spdlog"): _tag(tag)
+    explicit android_sink(const std::string& tag = "spdlog"): _tag(tag) {}
+
+    void log(const details::log_msg& msg) override
    {
+        const android_LogPriority priority = convert_to_android(msg.level);
+        // See system/core/liblog/logger_write.c for explanation of return value
+        const int ret = __android_log_write(
+                            priority, _tag.c_str(), msg.formatted.c_str()
+                        );
+        if (ret < 0)
+        {
+            throw spdlog_ex("__android_log_write() failed", ret);
+        }
    }

    void flush() override
    {
    }

-protected:
-    void _sink_it(const details::log_msg& msg) override
-    {
-        const android_LogPriority priority = convert_to_android(msg.level);
-        const int expected_size = msg.formatted.size();
-        const int size = __android_log_write(
-                             priority, _tag.c_str(), msg.formatted.c_str()
-                         );
-        if (size > expected_size)
-        {
-            // Will write a little bit more than original message
-        }
-        else
-        {
-            throw spdlog_ex("Send to Android logcat failed");
-        }
-    }
-
 private:
    static android_LogPriority convert_to_android(spdlog::level::level_enum level)
    {
@@ -63,29 +55,20 @@ private:
            return ANDROID_LOG_DEBUG;
        case spdlog::level::info:
            return ANDROID_LOG_INFO;
-        case spdlog::level::notice:
-            return ANDROID_LOG_INFO;
        case spdlog::level::warn:
            return ANDROID_LOG_WARN;
        case spdlog::level::err:
            return ANDROID_LOG_ERROR;
        case spdlog::level::critical:
            return ANDROID_LOG_FATAL;
-        case spdlog::level::alert:
-            return ANDROID_LOG_FATAL;
-        case spdlog::level::emerg:
-            return ANDROID_LOG_FATAL;
        default:
-            throw spdlog_ex("Incorrect level value");
+            return ANDROID_LOG_DEFAULT;
        }
    }

    std::string _tag;
 };

-typedef base_android_sink<std::mutex> android_sink_mt;
-typedef base_android_sink<details::null_mutex> android_sink_st;
-
 }
 }

--- a/include/spdlog/sinks/base_sink.h
+++ b/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>
--- a/include/spdlog/sinks/dist_sink.h
+++ b/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,37 @@ 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++)
-            (*iter)->log(msg);
+        for (auto &sink : _sinks)
+        {
+            if( sink->should_log( msg.level))
+            {
+                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++)
-            (*iter)->flush();
+        for (auto &sink : _sinks)
+            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);
-        }
+        _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);
-        if (pos != _sinks.end())
-        {
-            _sinks.erase(pos);
-        }
+        _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), sink), _sinks.end());
    }
 };

--- a/include/spdlog/sinks/file_sinks.h
+++ b/include/spdlog/sinks/file_sinks.h
@@ -23,17 +23,15 @@ namespace spdlog
 namespace sinks
 {
 /*
-* Trivial file sink with single file as target
-*/
+ * Trivial file sink with single file as target
+ */
 template<class Mutex>
 class simple_file_sink : public base_sink < Mutex >
 {
 public:
-    explicit simple_file_sink(const filename_t &filename,
-                              bool force_flush = false) :
-        _file_helper(force_flush)
+    explicit simple_file_sink(const filename_t &filename, bool truncate = false)  
    {
-        _file_helper.open(filename);
+        _file_helper.open(filename, truncate);
    }
    void flush() override
    {
@@ -53,21 +51,20 @@ typedef simple_file_sink<std::mutex> simple_file_sink_mt;
 typedef simple_file_sink<details::null_mutex> simple_file_sink_st;

 /*
-* Rotating file sink based on size
-*/
+ * Rotating file sink based on size
+ */
 template<class Mutex>
 class rotating_file_sink : public base_sink < Mutex >
 {
 public:
    rotating_file_sink(const filename_t &base_filename, const filename_t &extension,
-                       std::size_t max_size, std::size_t max_files,
-                       bool force_flush = false) :
+                       std::size_t max_size, std::size_t max_files                       ) :
        _base_filename(base_filename),
        _extension(extension),
        _max_size(max_size),
        _max_files(max_files),
        _current_size(0),
-        _file_helper(force_flush)
+        _file_helper()
    {
        _file_helper.open(calc_filename(_base_filename, 0, _extension));
        _current_size = _file_helper.size(); //expensive. called only once
@@ -142,11 +139,11 @@ typedef rotating_file_sink<std::mutex> rotating_file_sink_mt;
 typedef rotating_file_sink<details::null_mutex>rotating_file_sink_st;

 /*
-* Default generator of daily log file names.
-*/
+ * Default generator of daily log file names.
+ */
 struct default_daily_file_name_calculator
 {
-    //Create filename for the form basename.YYYY-MM-DD_hh-mm.extension
+    // Create filename for the form basename.YYYY-MM-DD_hh-mm.extension
    static filename_t calc_filename(const filename_t& basename, const filename_t& extension)
    {
        std::tm tm = spdlog::details::os::localtime();
@@ -157,11 +154,11 @@ struct default_daily_file_name_calculator
 };

 /*
-* Generator of daily log file names in format basename.YYYY-MM-DD.extension
-*/
+ * Generator of daily log file names in format basename.YYYY-MM-DD.extension
+ */
 struct dateonly_daily_file_name_calculator
 {
-    //Create filename for the form basename.YYYY-MM-DD.extension
+    // Create filename for the form basename.YYYY-MM-DD.extension
    static filename_t calc_filename(const filename_t& basename, const filename_t& extension)
    {
        std::tm tm = spdlog::details::os::localtime();
@@ -172,8 +169,8 @@ struct dateonly_daily_file_name_calculator
 };

 /*
-* Rotating file sink based on date. rotates at midnight
-*/
+ * Rotating file sink based on date. rotates at midnight
+ */
 template<class Mutex, class FileNameCalc = default_daily_file_name_calculator>
 class daily_file_sink :public base_sink < Mutex >
 {
@@ -183,12 +180,10 @@ public:
        const filename_t& base_filename,
        const filename_t& extension,
        int rotation_hour,
-        int rotation_minute,
-        bool force_flush = false) : _base_filename(base_filename),
+        int rotation_minute) : _base_filename(base_filename),
        _extension(extension),
        _rotation_h(rotation_hour),
-        _rotation_m(rotation_minute),
-        _file_helper(force_flush)
+        _rotation_m(rotation_minute)        
    {
        if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59)
            throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
--- a/include/spdlog/sinks/sink.h
+++ b/include/spdlog/sinks/sink.h
@@ -15,10 +15,36 @@ namespace sinks
 class sink
 {
 public:
+    sink(): _level( level::trace ) {}
+
    virtual ~sink() {}
    virtual void log(const details::log_msg& msg) = 0;
    virtual void flush() = 0;
+
+    bool should_log(level::level_enum msg_level) const;
+    void set_level(level::level_enum log_level);
+    level::level_enum level() const;
+
+private:
+    level_t _level;
+
 };
+
+inline bool sink::should_log(level::level_enum msg_level) const
+{
+    return msg_level >= _level.load(std::memory_order_relaxed);
+}
+
+inline void sink::set_level(level::level_enum log_level)
+{
+    _level.store(log_level);
+}
+
+inline level::level_enum sink::level() const
+{
+    return static_cast<spdlog::level::level_enum>(_level.load(std::memory_order_relaxed));
+}
+
 }
 }

--- a/include/spdlog/sinks/syslog_sink.h
+++ b/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>
--- a/include/spdlog/spdlog.h
+++ b/include/spdlog/spdlog.h
@@ -20,15 +20,13 @@
 namespace spdlog
 {

-// Return an existing logger or nullptr if a logger with such name doesn't exist.
-// Examples:
 //
-// spdlog::get("mylog")->info("Hello");
-// auto logger = spdlog::get("mylog");
-// logger.info("This is another message" , x, y, z);
-// logger.info() << "This is another message" << x << y << z;
+// Return an existing logger or nullptr if a logger with such name doesn't exist.
+// example: spdlog::get("my_logger")->info("hello {}", "world");
+//
 std::shared_ptr<logger> get(const std::string& name);

+
 //
 // Set global formatting
 // example: spdlog::set_pattern("%Y-%m-%d %H:%M:%S.%e %l : %v");
@@ -41,6 +39,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.
@@ -64,22 +67,23 @@ void set_sync_mode();


 //
-// Create and register multi/single basic file logger
+// Create and register multi/single threaded basic file logger.
+// Basic logger simply writes to given file without any limitatons or rotations.
 //
-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_st(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 truncate = false);
+std::shared_ptr<logger> basic_logger_st(const std::string& logger_name, const filename_t& filename, bool truncate = false);

 //
 // Create and register multi/single threaded rotating file logger
 //
-std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const filename_t& 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 filename_t& filename, size_t max_file_size, size_t max_files, bool force_flush = false);
+std::shared_ptr<logger> rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files);
+std::shared_ptr<logger> rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files);

 //
 // 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 filename_t& filename, int hour=0, int minute=0, bool force_flush = false);
-std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0, bool force_flush = false);
+std::shared_ptr<logger> daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);
+std::shared_ptr<logger> daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour=0, int minute=0);

 //
 // Create and register stdout/stderr loggers
@@ -93,10 +97,13 @@ 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

+#if defined(__ANDROID__)
+std::shared_ptr<logger> android_logger(const std::string& logger_name, const std::string& tag = "spdlog");
+#endif

 // Create and register a logger a single sink
 std::shared_ptr<logger> create(const std::string& logger_name, const sink_ptr& sink);
@@ -108,7 +115,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 +124,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();


--- a/include/spdlog/tweakme.h
+++ b/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
+///////////////////////////////////////////////////////////////////////////////
+
+
--- a/tests/errors.cpp
+++ b/tests/errors.cpp
@@ -0,0 +1,64 @@
+/*
+* 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->flush_on(spdlog::level::info);
+    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);
+}
--- a/tests/file_helper.cpp
+++ b/tests/file_helper.cpp
@@ -12,6 +12,7 @@ static void write_with_helper(file_helper &helper, size_t howmany)
    log_msg msg;
    msg.formatted << std::string(howmany, '1');
    helper.write(msg);
+	helper.flush();
 }


@@ -19,7 +20,7 @@ TEST_CASE("file_helper_filename", "[file_helper::filename()]]")
 {
    prepare_logdir();

-    file_helper helper(false);
+    file_helper helper;
    helper.open(target_filename);
    REQUIRE(helper.filename() == target_filename);
 }
@@ -31,7 +32,7 @@ TEST_CASE("file_helper_size", "[file_helper::size()]]")
    prepare_logdir();
    size_t expected_size = 123;
    {
-        file_helper helper(true);
+        file_helper helper;
        helper.open(target_filename);
        write_with_helper(helper, expected_size);
        REQUIRE(static_cast<size_t>(helper.size()) == expected_size);
@@ -44,7 +45,7 @@ TEST_CASE("file_helper_exists", "[file_helper::file_exists()]]")
 {
    prepare_logdir();
    REQUIRE(!file_helper::file_exists(target_filename));
-    file_helper helper(false);
+	file_helper helper;
    helper.open(target_filename);
    REQUIRE(file_helper::file_exists(target_filename));
 }
@@ -52,7 +53,7 @@ TEST_CASE("file_helper_exists", "[file_helper::file_exists()]]")
 TEST_CASE("file_helper_reopen", "[file_helper::reopen()]]")
 {
    prepare_logdir();
-    file_helper helper(true);
+    file_helper helper;
    helper.open(target_filename);
    write_with_helper(helper, 12);
    REQUIRE(helper.size() == 12);
@@ -64,7 +65,7 @@ TEST_CASE("file_helper_reopen2", "[file_helper::reopen(false)]]")
 {
    prepare_logdir();
    size_t expected_size = 14;
-    file_helper helper(true);
+	file_helper helper;
    helper.open(target_filename);
    write_with_helper(helper, expected_size);
    REQUIRE(helper.size() == expected_size);
--- a/tests/file_log.cpp
+++ b/tests/file_log.cpp
@@ -18,22 +18,40 @@ TEST_CASE("simple_file_logger", "[simple_logger]]")
    logger->flush();
    REQUIRE(file_contents(filename) == std::string("Test message 1\nTest message 2\n"));
    REQUIRE(count_lines(filename) == 2);
+}

+
+TEST_CASE("flush_on", "[flush_on]]")
+{
+	prepare_logdir();
+	std::string filename = "logs/simple_log.txt";
+
+	auto logger = spdlog::create<spdlog::sinks::simple_file_sink_mt>("logger", filename);
+	logger->set_pattern("%v");
+	logger->set_level(spdlog::level::trace);
+	logger->flush_on(spdlog::level::info);
+	logger->trace("Should not be flushed");
+	REQUIRE(count_lines(filename) == 0);
+
+	logger->info("Test message {}", 1);
+	logger->info("Test message {}", 2);
+	logger->flush();
+	REQUIRE(file_contents(filename) == std::string("Should not be flushed\nTest message 1\nTest message 2\n"));
+	REQUIRE(count_lines(filename) == 3);
 }

 TEST_CASE("rotating_file_logger1", "[rotating_logger]]")
 {
    prepare_logdir();
    std::string basename = "logs/rotating_log";
-    auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 0, true);
+    auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 0);
+    
    for (int i = 0; i < 10; ++i)
        logger->info("Test message {}", i);

+	logger->flush();
    auto filename = basename + ".txt";
    REQUIRE(count_lines(filename) == 10);
-    for (int i = 0; i < 1000; i++)
-        logger->info("Test message {}", i);
-
 }


@@ -41,7 +59,7 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]]")
 {
    prepare_logdir();
    std::string basename = "logs/rotating_log";
-    auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 1, false);
+    auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 1);
    for (int i = 0; i < 10; ++i)
        logger->info("Test message {}", i);

@@ -60,7 +78,6 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]]")

 TEST_CASE("daily_logger", "[daily_logger]]")
 {
-
    prepare_logdir();
    //calculate filename (time based)
    std::string basename = "logs/daily_log";
@@ -68,7 +85,8 @@ TEST_CASE("daily_logger", "[daily_logger]]")
    fmt::MemoryWriter w;
    w.write("{}_{:04d}-{:02d}-{:02d}_{:02d}-{:02d}.txt", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min);

-    auto logger = spdlog::daily_logger_mt("logger", basename, 0, 0, true);
+    auto logger = spdlog::daily_logger_mt("logger", basename, 0, 0);
+    logger->flush_on(spdlog::level::info);
    for (int i = 0; i < 10; ++i)
        logger->info("Test message {}", i);

@@ -90,10 +108,10 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger_dateonly]]")
    fmt::MemoryWriter w;
    w.write("{}_{:04d}-{:02d}-{:02d}.txt", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);

-    auto logger = spdlog::create<sink_type>("logger", basename, "txt", 0, 0, true);
+    auto logger = spdlog::create<sink_type>("logger", basename, "txt", 0, 0);
    for (int i = 0; i < 10; ++i)
        logger->info("Test message {}", i);
-
+	logger->flush();
    auto filename = w.str();
    REQUIRE(count_lines(filename) == 10);
 }
@@ -122,11 +140,12 @@ TEST_CASE("daily_logger with custom calculator", "[daily_logger_custom]]")
    fmt::MemoryWriter w;
    w.write("{}{:04d}{:02d}{:02d}.txt", basename, tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday);

-    auto logger = spdlog::create<sink_type>("logger", basename, "txt", 0, 0, true);
+    auto logger = spdlog::create<sink_type>("logger", basename, "txt", 0, 0);
    for (int i = 0; i < 10; ++i)
        logger->info("Test message {}", i);

-    auto filename = w.str();
+	logger->flush();
+    auto filename = w.str();	
    REQUIRE(count_lines(filename) == 10);
 }

--- a/tests/format.cpp
+++ b/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);
-
-}
+



--- a/tests/registry.cpp
+++ b/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();
 }

+
+
--- a/tests/tests.vcxproj
+++ b/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" />
--- a/tests/tests.vcxproj.filters
+++ b/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">
Author	SHA1	Message	Date
gabime	1f1f6a5f3b	Support bench under OSX	2016-09-18 02:28:41 +03:00
gabime	214c67788f	add async with null sink bench	2016-09-18 01:51:53 +03:00
gabime	e97621d61d	Removed force_flush arg from everywhere. Use flush_on(level) instead	2016-09-18 00:43:42 +03:00
gabime	b0f8230783	Fixed bug in basic_logger creating (passed truncate to force_flush arg)	2016-09-18 00:14:56 +03:00
Gabi Melman	9c04504881	Update README.md	2016-09-16 02:58:02 +03:00
gabime	5653e5c9d7	astyle	2016-09-15 00:38:21 +03:00
gabime	6312748cc7	updated bundled fmt to version 1fb0586b065c4202e976528a6bdc6384dc56dc04	2016-09-15 00:35:51 +03:00
Gabi Melman	87d79eb95d	Merge pull request #277 from hghwng/master Fix compilation on Android.	2016-09-14 17:55:43 +03:00
Hugh Wang	96267654e6	Add Android examples.	2016-09-14 17:39:15 +08:00
Hugh Wang	72a6fd65da	Support direct creation of android logger.	2016-09-14 17:37:06 +08:00
Hugh Wang	bf02f57475	Fix Android sink. 1. Remove lock. 2. Improve error detection. 3. Remove unsupported log levels.	2016-09-14 17:37:06 +08:00
Hugh Wang	f2c9692438	Fix compilation on Android.	2016-09-14 17:37:06 +08:00
Gabi Melman	59bf37f769	Merge pull request #279 from facontidavide/loglevel_per_sink Loglevel per sink. Thanks @facontidavide	2016-09-13 00:04:59 +03:00
davide	d79af47a28	added example	2016-09-12 22:28:37 +02:00
davide	b67076fc85	added level_t to sink. Improves the flexibility of loggers with multiple sinks	2016-09-12 22:26:38 +02:00
Gabi Melman	c69df8ae44	Update spdlog.h	2016-09-03 14:15:09 +03:00
Gabi Melman	b18d235b63	Update spdlog.h	2016-09-03 14:08:55 +03:00
Gabi Melman	01ef3d3114	Update async_logger_impl.h	2016-09-03 01:35:10 +03:00
Gabi Melman	d01e288afc	fix flush async flush	2016-09-03 01:33:07 +03:00
gabime	3ee1bab316	added std:: to vector decl in bench	2016-09-02 17:24:40 +03:00
gabime	c3757c99d5	remoed zf_log from bench	2016-09-02 17:23:40 +03:00
gabime	2d64a1de1c	fixed bench compilation	2016-09-02 17:16:02 +03:00
gabime	0d35df584c	removed zf_log from bench	2016-09-02 17:14:48 +03:00
gabime	3afabcd17e	astyle	2016-09-02 17:06:00 +03:00
gabime	d2a367fa7c	Fixed tests after remove of force_flush arg	2016-09-02 16:59:55 +03:00
gabime	e562e001cf	Removed force_flush arg from API (use flush_on(level) instead)	2016-09-02 16:59:15 +03:00
gabime	1df30a0733	support flush_on(..) in async loggers too	2016-09-02 16:19:29 +03:00
gabime	3a12f3c560	fix typo in example	2016-09-02 15:00:51 +03:00
Gabi Melman	f310cc460f	Update README.md	2016-08-26 15:39:00 +03:00
Gabi Melman	2fa29987ca	Update README.md	2016-08-26 14:16:36 +03:00
gabime	8cf39857ab	style	2016-08-26 00:38:08 +03:00
gabime	cb75569541	Fixed issue #266 (Improperly-formatted ISO8601 UTC offset for negative-offset timezones)	2016-08-26 00:37:41 +03:00
Gabi Melman	bf327be7f5	Update README.md	2016-08-24 03:04:55 +03:00
Gabi Melman	6dfdaa3532	Update README.md	2016-08-24 03:03:58 +03:00
Gabi Melman	6e1bd45d66	Update README.md	2016-08-24 03:02:01 +03:00
Gabi Melman	cfcd44ca36	Update README.md	2016-08-24 03:00:55 +03:00
Gabi Melman	42dfa1975a	Merge pull request #265 from sbrkopac/master Added the ability to truncate the basic file logger.	2016-08-23 00:00:49 +03:00
Sam Brkopac	0be736c7fc	Added the ability to truncate the basic file logger. Added the ability to truncate the basic file logger.	2016-08-22 13:31:43 -07:00
gabime	332b7c0d7f	astyle	2016-08-22 22:09:23 +03:00
gabime	4f52cc4dec	async flush now waits for queue to be empty before returning	2016-08-22 22:07:29 +03:00
gabime	dfa2c7a950	async flush now waits for queue to be empty before returning	2016-08-22 21:48:57 +03:00
Gabi Melman	73a3a32325	Update README.md	2016-08-22 21:15:54 +03:00
Gabi Melman	742922f029	Update README.md	2016-08-22 21:13:15 +03:00
gabime	b13735dc22	astyle	2016-08-22 20:54:18 +03:00
gabime	20cb73e9da	disable syslog by default (enable by #define SPDLOG_ENABLE_SYSLOG )	2016-08-22 20:52:16 +03:00
Gabi Melman	c68a0de2b6	Merge pull request #263 from jan-dx/master Add support for Solaris operating system	2016-08-22 20:20:40 +03:00
Nazım Can Bedir	097ba5a359	Add basic support for Solaris.	2016-08-22 17:26:12 +03:00
Nazım Can Bedir	e277f9b05c	Make syslog backend tweakable.	2016-08-22 16:39:46 +03:00
Nazım Can Bedir	2678c37b56	Move syslog support tests to one place.	2016-08-22 16:39:13 +03:00
gabime	e556daebc3	better support for thread id in FreeBSD	2016-08-21 01:36:27 +03:00
gabime	2705e35a8c	updated example	2016-08-21 01:21:18 +03:00
gabime	86de264da9	Added support for syslog in FreeBSD	2016-08-21 01:16:04 +03:00
gabime	5b2bd79b7e	Added support for syslog in FreeBSD	2016-08-21 00:57:53 +03:00
gabime	aa0f62292b	fixed dist_sink in gcc	2016-08-20 15:01:08 +03:00
gabime	916a686f8f	astyle	2016-08-20 14:55:50 +03:00
gabime	2c32f826ab	Merge branch 'master' of https://github.com/gabime/spdlog	2016-08-20 14:54:33 +03:00
gabime	c4298a989e	dist sink cleanup	2016-08-20 14:52:26 +03:00
Gabi Melman	c16f89d044	Update README.md	2016-08-20 14:11:56 +03:00
Gabi Melman	f09e0bd047	Update README.md	2016-08-20 14:11:28 +03:00
Gabi Melman	23060c6c9d	Update README.md	2016-08-20 14:10:38 +03:00
Gabi Melman	efc8de6d64	Update README.md	2016-08-20 14:01:40 +03:00
gabime	4efbd950d6	atyle	2016-08-20 13:55:50 +03:00
gabime	d8f01c3a72	added apply_al()l test to tests	2016-08-20 13:51:07 +03:00
gabime	3af247fbd3	Added a way to iterate all registered loggers (issues #238 and #259 ).	2016-08-20 13:37:36 +03:00
gabime	1c4da3eef3	fixed example async error	2016-08-20 13:26:13 +03:00
Gabi Melman	4fcde3b850	Update README.md	2016-08-05 14:27:58 +03:00
gabime	e7debaacd7	astyle	2016-08-05 04:43:20 +03:00
Gabi Melman	bdbe908693	Update README.md	2016-08-05 04:23:34 +03:00
gabime	39cdd08a54	no exceptions while logging	2016-08-05 03:56:40 +03:00
Gabi Melman	2fc332abdc	Update README.md	2016-08-04 03:11:56 +03:00
Gabi Melman	f05451650d	Merge pull request #255 from Cleroth/patch-1 m	2016-08-03 12:20:13 +03:00
Cleroth	9a888cde56	m	2016-08-03 10:43:33 +02:00
Gabi Melman	d9304f17f5	Merge pull request #254 from tony/freebsd-compat Add FreeBSD compatibility defs	2016-08-01 12:40:58 +03:00
Tony Narlock	98af71c585	Add FreeBSD compatibility defs fix some linux-isms for spdlog on freebsd systems - FreeBSD uses plain-old ``stat`` (not ``stat64``) - ``errno_str``'s else requires GNU extensions, not available by default on FreeBSD. The one used by apple systems is most correct	2016-08-01 00:19:35 -05:00
Gabi Melman	cee155c1dd	typo in comment	2016-08-01 00:38:59 +03:00