Support bench under OSX

Fix compilation on Android.

.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

README.md

@@ -11,6 +11,7 @@ Just copy the source [folder](https://github.com/gabime/spdlog/tree/master/inclu
  * 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).
@@ -57,13 +58,7 @@ Time needed to log 1,000,000 lines in asynchronous mode, i.e. the time it takes
 
 ## Usage Example
 ```c++
-//
-// Copyright(c) 2015 Gabi Melman.
-// Distributed under the MIT License (http://opensource.org/licenses/MIT)
-//
-//
-// spdlog usage example
-//
+
 #include "spdlog/spdlog.h"
 
 #include <iostream>
@@ -82,7 +77,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->info("An info message example {}..", 1);
 
         // Formatting examples
         console->warn("Easy padding in numbers like {:08d}", 12);

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

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

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

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

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

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

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)

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

example/example.cpp

@@ -13,6 +13,7 @@
 
 void async_example();
 void syslog_example();
+void android_example();
 void user_defined_example();
 void err_handler_example();
 
@@ -24,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);
@@ -48,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)
@@ -56,6 +56,8 @@ 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
@@ -74,6 +76,9 @@ int main(int, char*[])
         // syslog example. linux/osx only
         syslog_example();
 
+        // android example. compile with NDK
+        android_example();
+
         // Log user-defined types example
         user_defined_example();
 
@@ -102,6 +107,7 @@ 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);
 }
@@ -116,6 +122,16 @@ void syslog_example()
 #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
+}
+
 // user defined types logging by implementing operator<<
 struct my_type
 {
@@ -145,4 +161,3 @@ void err_handler_example()
     });
     spd::get("console")->info("some invalid message to trigger an error {}{}{}{}", 3);
 }
-

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)

example/jni/Application.mk

@@ -0,0 +1,2 @@
+# Exceptions are used in spdlog. Link to an exception-ready C++ runtime.
+APP_STL = gnustl_static

example/jni/example.cpp

@@ -0,0 +1 @@
+../example.cpp

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

include/spdlog/details/async_log_helper.h

@@ -133,7 +133,7 @@ public:
 
     void set_formatter(formatter_ptr);
 
-    void flush();
+    void flush(bool wait_for_q);
 
 
 private:
@@ -249,12 +249,12 @@ inline void spdlog::details::async_log_helper::push_msg(details::async_log_helpe
 
 }
 
-//wait for the queue be empty and request flush from its sinks
-inline void spdlog::details::async_log_helper::flush()
+// 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)
 {
-    wait_empty_q();
     push_msg(async_msg(async_msg_type::flush));
-    wait_empty_q(); //make sure the above flush message was processed
+    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()
@@ -304,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;
     }
@@ -317,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;
-
     }
 }
 

include/spdlog/details/async_logger_impl.h

@@ -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)
@@ -76,6 +75,8 @@ inline void spdlog::async_logger::_sink_it(details::log_msg& 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)
     {

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,10 +89,7 @@ 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()
@@ -116,8 +112,7 @@ public:
 
 private:
     FILE* _fd;
-    filename_t _filename;
-    bool _force_flush;
+    filename_t _filename;    
 };
 }
 }

include/spdlog/details/logger_impl.h

@@ -244,13 +244,16 @@ inline bool spdlog::logger::should_log(spdlog::level::level_enum msg_level) cons
 //
 inline void spdlog::logger::_sink_it(details::log_msg& msg)
 {
-
     _formatter->format(msg);
     for (auto &sink : _sinks)
-        sink->log(msg);
+    {
+        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();
 }
 
@@ -282,3 +285,9 @@ inline void spdlog::logger::_default_err_handler(const std::string &msg)
     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);
+}

include/spdlog/details/os.h

@@ -342,7 +342,9 @@ inline std::string errno_str(int err_num)
     else
         return "Unkown error";
 
-#elif defined(__FreeBSD__) || 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
@@ -356,5 +358,3 @@ inline std::string errno_str(int err_num)
 } //os
 } //details
 } //spdlog
-
-

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, bool truncate)
+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, truncate);
+    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, bool truncate)
+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, truncate);
+    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)
@@ -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)
 {

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>
 

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, ...) \

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

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

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_

include/spdlog/logger.h

@@ -65,6 +65,7 @@ public:
 
     // automatically call flush() if message level >= log_level
     void flush_on(level::level_enum log_level);
+
     virtual void flush();
 
 protected:
@@ -75,6 +76,9 @@ protected:
     // 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;

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

include/spdlog/sinks/dist_sink.h

@@ -36,10 +36,14 @@ protected:
     void _sink_it(const details::log_msg& msg) override
     {
         for (auto &sink : _sinks)
-            sink->log(msg);
+        {
+            if( sink->should_log( msg.level))
+            {
+                sink->log(msg);
+            }
+        }
     }
 
-
 public:
     void flush() override
     {

include/spdlog/sinks/file_sinks.h

@@ -23,16 +23,13 @@ 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,
-                              bool truncate = false) :
-        _file_helper(force_flush)
+    explicit simple_file_sink(const filename_t &filename, bool truncate = false)  
     {
         _file_helper.open(filename, truncate);
     }
@@ -54,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
@@ -143,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();
@@ -158,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();
@@ -173,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 >
 {
@@ -184,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");

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

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");
@@ -69,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, bool truncate = false);
-std::shared_ptr<logger> basic_logger_st(const std::string& logger_name, const filename_t& filename, bool force_flush = false, bool truncate = 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
@@ -102,6 +101,9 @@ std::shared_ptr<logger> stderr_logger_st(const std::string& logger_name, bool co
 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);

tests/errors.cpp

@@ -28,6 +28,7 @@ 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();

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

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