[med-svn] [spdlog] 01/01: New upstream version 0.11.0
Michael Crusoe
misterc-guest at moszumanska.debian.org
Sun Oct 9 09:01:43 UTC 2016
This is an automated email from the git hooks/post-receive script.
misterc-guest pushed a commit to annotated tag upstream/0.11.0
in repository spdlog.
commit e67cb72a65fa98c8cba1254b515557a8e38604a6
Author: Michael R. Crusoe <michael.crusoe at gmail.com>
Date: Sun Oct 9 01:15:12 2016 -0700
New upstream version 0.11.0
---
.gitignore | 4 +-
README.md | 1 +
bench/Makefile | 13 ++--
bench/spdlog-bench-mt.cpp | 2 +-
bench/spdlog-null-async.cpp | 112 +++++++++++++++++++++++++++++
bench/utils.h | 35 +++++++++
bench/zf_log-bench-mt.cpp | 56 ---------------
bench/zf_log-bench.cpp | 28 --------
example/CMakeLists.txt | 3 +
example/bench.cpp | 17 +++--
example/example.cpp | 21 +++++-
example/jni/Android.mk | 15 ++++
example/jni/Application.mk | 2 +
example/jni/example.cpp | 1 +
example/multisink.cpp | 47 ++++++++++++
include/spdlog/details/async_log_helper.h | 18 +++--
include/spdlog/details/async_logger_impl.h | 5 +-
include/spdlog/details/file_helper.h | 13 ++--
include/spdlog/details/logger_impl.h | 17 +++--
include/spdlog/details/os.h | 6 +-
include/spdlog/details/spdlog_impl.h | 32 +++++----
include/spdlog/fmt/bundled/format.cc | 6 +-
include/spdlog/fmt/bundled/format.h | 56 ++++++++++++---
include/spdlog/fmt/bundled/ostream.cc | 19 ++---
include/spdlog/fmt/bundled/ostream.h | 19 ++---
include/spdlog/fmt/bundled/printf.h | 20 +++++-
include/spdlog/logger.h | 4 ++
include/spdlog/sinks/android_sink.h | 53 +++++---------
include/spdlog/sinks/dist_sink.h | 8 ++-
include/spdlog/sinks/file_sinks.h | 40 +++++------
include/spdlog/sinks/sink.h | 26 +++++++
include/spdlog/spdlog.h | 26 +++----
tests/errors.cpp | 1 +
tests/file_helper.cpp | 11 +--
tests/file_log.cpp | 41 ++++++++---
35 files changed, 507 insertions(+), 271 deletions(-)
diff --git a/.gitignore b/.gitignore
index 39b7548..b51a05b 100644
--- 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
diff --git a/README.md b/README.md
index 435ce5d..e023c56 100644
--- a/README.md
+++ b/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).
diff --git a/bench/Makefile b/bench/Makefile
index 8416d04..418a528 100644
--- 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
diff --git a/bench/spdlog-bench-mt.cpp b/bench/spdlog-bench-mt.cpp
index 28f8780..e28e7bb 100644
--- 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)
{
diff --git a/bench/spdlog-null-async.cpp b/bench/spdlog-null-async.cpp
new file mode 100644
index 0000000..435d7eb
--- /dev/null
+++ 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;
+}
diff --git a/bench/utils.h b/bench/utils.h
new file mode 100644
index 0000000..b260f72
--- /dev/null
+++ 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();
+}
+
+}
diff --git a/bench/zf_log-bench-mt.cpp b/bench/zf_log-bench-mt.cpp
deleted file mode 100644
index aace277..0000000
--- a/bench/zf_log-bench-mt.cpp
+++ /dev/null
@@ -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;
-}
diff --git a/bench/zf_log-bench.cpp b/bench/zf_log-bench.cpp
deleted file mode 100644
index a6e3e1f..0000000
--- a/bench/zf_log-bench.cpp
+++ /dev/null
@@ -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;
-}
diff --git a/example/CMakeLists.txt b/example/CMakeLists.txt
index 1944aca..7859e4d 100644
--- 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)
diff --git a/example/bench.cpp b/example/bench.cpp
index d45705b..b21c443 100644
--- 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");
}
diff --git a/example/example.cpp b/example/example.cpp
index a150ed7..2323b57 100644
--- a/example/example.cpp
+++ b/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);
}
-
diff --git a/example/jni/Android.mk b/example/jni/Android.mk
new file mode 100644
index 0000000..7accbad
--- /dev/null
+++ 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)
diff --git a/example/jni/Application.mk b/example/jni/Application.mk
new file mode 100644
index 0000000..dccd2a5
--- /dev/null
+++ 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
diff --git a/example/jni/example.cpp b/example/jni/example.cpp
new file mode 120000
index 0000000..6170abc
--- /dev/null
+++ b/example/jni/example.cpp
@@ -0,0 +1 @@
+../example.cpp
\ No newline at end of file
diff --git a/example/multisink.cpp b/example/multisink.cpp
new file mode 100644
index 0000000..fe6539b
--- /dev/null
+++ 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;
+ }
+}
+
diff --git a/include/spdlog/details/async_log_helper.h b/include/spdlog/details/async_log_helper.h
index 347b203..7e9b3eb 100644
--- a/include/spdlog/details/async_log_helper.h
+++ b/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;
-
}
}
diff --git a/include/spdlog/details/async_logger_impl.h b/include/spdlog/details/async_logger_impl.h
index bb518dc..736d2e3 100644
--- a/include/spdlog/details/async_logger_impl.h
+++ b/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)
{
diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h
index 37f1cf2..2e6ce9d 100644
--- 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,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;
};
}
}
diff --git a/include/spdlog/details/logger_impl.h b/include/spdlog/details/logger_impl.h
index b9f4100..a337b35 100644
--- a/include/spdlog/details/logger_impl.h
+++ b/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);
+}
diff --git a/include/spdlog/details/os.h b/include/spdlog/details/os.h
index eb95e44..ed4f45c 100644
--- a/include/spdlog/details/os.h
+++ b/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
-
-
diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h
index fb4e6f8..bc283c8 100644
--- 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, 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)
{
diff --git a/include/spdlog/fmt/bundled/format.cc b/include/spdlog/fmt/bundled/format.cc
index 161511d..0f7e0aa 100644
--- 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>
diff --git a/include/spdlog/fmt/bundled/format.h b/include/spdlog/fmt/bundled/format.h
index 8fc331e..294a686 100644
--- 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, ...) \
diff --git a/include/spdlog/fmt/bundled/ostream.cc b/include/spdlog/fmt/bundled/ostream.cc
index 6309e08..4d4a9a4 100644
--- 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
diff --git a/include/spdlog/fmt/bundled/ostream.h b/include/spdlog/fmt/bundled/ostream.h
index e318a17..37e08f3 100644
--- 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
diff --git a/include/spdlog/fmt/bundled/printf.h b/include/spdlog/fmt/bundled/printf.h
index 7fd1eac..77e6840 100644
--- 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_
diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h
index 88c982f..e998999 100644
--- a/include/spdlog/logger.h
+++ b/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;
diff --git a/include/spdlog/sinks/android_sink.h b/include/spdlog/sinks/android_sink.h
index 885f78d..d8c97e0 100644
--- 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)
- {
- }
-
- void flush() override
- {
- }
+ explicit android_sink(const std::string& tag = "spdlog"): _tag(tag) {}
-protected:
- void _sink_it(const details::log_msg& msg) override
+ void log(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)
+ // 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)
{
- // Will write a little bit more than original message
- }
- else
- {
- throw spdlog_ex("Send to Android logcat failed");
+ throw spdlog_ex("__android_log_write() failed", ret);
}
}
+ void flush() override
+ {
+ }
+
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;
-
}
}
diff --git a/include/spdlog/sinks/dist_sink.h b/include/spdlog/sinks/dist_sink.h
index 3498a74..cef08bf 100644
--- a/include/spdlog/sinks/dist_sink.h
+++ b/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
{
diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h
index ff76759..fad21fe 100644
--- a/include/spdlog/sinks/file_sinks.h
+++ b/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");
diff --git a/include/spdlog/sinks/sink.h b/include/spdlog/sinks/sink.h
index 39dc771..d27fdbe 100644
--- 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));
+}
+
}
}
diff --git a/include/spdlog/spdlog.h b/include/spdlog/spdlog.h
index e2b8ba4..d4f4203 100644
--- 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:
+// example: spdlog::get("my_logger")->info("hello {}", "world");
//
-// 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;
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);
diff --git a/tests/errors.cpp b/tests/errors.cpp
index 6cb4265..04cd97c 100644
--- a/tests/errors.cpp
+++ b/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();
diff --git a/tests/file_helper.cpp b/tests/file_helper.cpp
index 54d54cf..599c233 100644
--- 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);
diff --git a/tests/file_log.cpp b/tests/file_log.cpp
index f9b23f7..ab1d943 100644
--- 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);
}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/debian-med/spdlog.git
More information about the debian-med-commit
mailing list