diff options
Diffstat (limited to 'deps/include/spdlog/sinks')
34 files changed, 3500 insertions, 0 deletions
diff --git a/deps/include/spdlog/sinks/android_sink.h b/deps/include/spdlog/sinks/android_sink.h new file mode 100644 index 0000000..f5a0aea --- /dev/null +++ b/deps/include/spdlog/sinks/android_sink.h @@ -0,0 +1,137 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifdef __ANDROID__
+
+ #include <spdlog/details/fmt_helper.h>
+ #include <spdlog/details/null_mutex.h>
+ #include <spdlog/details/os.h>
+ #include <spdlog/details/synchronous_factory.h>
+ #include <spdlog/sinks/base_sink.h>
+
+ #include <android/log.h>
+ #include <chrono>
+ #include <mutex>
+ #include <string>
+ #include <thread>
+ #include <type_traits>
+
+ #if !defined(SPDLOG_ANDROID_RETRIES)
+ #define SPDLOG_ANDROID_RETRIES 2
+ #endif
+
+namespace spdlog {
+namespace sinks {
+
+/*
+ * Android sink
+ * (logging using __android_log_write or __android_log_buf_write depending on the specified
+ * BufferID)
+ */
+template <typename Mutex, int BufferID = log_id::LOG_ID_MAIN>
+class android_sink final : public base_sink<Mutex> {
+public:
+ explicit android_sink(std::string tag = "spdlog", bool use_raw_msg = false)
+ : tag_(std::move(tag)),
+ use_raw_msg_(use_raw_msg) {}
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ const android_LogPriority priority = convert_to_android_(msg.level);
+ memory_buf_t formatted;
+ if (use_raw_msg_) {
+ details::fmt_helper::append_string_view(msg.payload, formatted);
+ } else {
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ }
+ formatted.push_back('\0');
+ const char *msg_output = formatted.data();
+
+ // See system/core/liblog/logger_write.c for explanation of return value
+ int ret = android_log(priority, tag_.c_str(), msg_output);
+ if (ret == -EPERM) {
+ return; // !__android_log_is_loggable
+ }
+ int retry_count = 0;
+ while ((ret == -11 /*EAGAIN*/) && (retry_count < SPDLOG_ANDROID_RETRIES)) {
+ details::os::sleep_for_millis(5);
+ ret = android_log(priority, tag_.c_str(), msg_output);
+ retry_count++;
+ }
+
+ if (ret < 0) {
+ throw_spdlog_ex("logging to Android failed", ret);
+ }
+ }
+
+ void flush_() override {}
+
+private:
+ // There might be liblog versions used, that do not support __android_log_buf_write. So we only
+ // compile and link against
+ // __android_log_buf_write, if user explicitly provides a non-default log buffer. Otherwise,
+ // when using the default log buffer, always log via __android_log_write.
+ template <int ID = BufferID>
+ typename std::enable_if<ID == static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
+ int prio, const char *tag, const char *text) {
+ return __android_log_write(prio, tag, text);
+ }
+
+ template <int ID = BufferID>
+ typename std::enable_if<ID != static_cast<int>(log_id::LOG_ID_MAIN), int>::type android_log(
+ int prio, const char *tag, const char *text) {
+ return __android_log_buf_write(ID, prio, tag, text);
+ }
+
+ static android_LogPriority convert_to_android_(spdlog::level::level_enum level) {
+ switch (level) {
+ case spdlog::level::trace:
+ return ANDROID_LOG_VERBOSE;
+ case spdlog::level::debug:
+ return ANDROID_LOG_DEBUG;
+ case spdlog::level::info:
+ 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;
+ default:
+ return ANDROID_LOG_DEFAULT;
+ }
+ }
+
+ std::string tag_;
+ bool use_raw_msg_;
+};
+
+using android_sink_mt = android_sink<std::mutex>;
+using android_sink_st = android_sink<details::null_mutex>;
+
+template <int BufferId = log_id::LOG_ID_MAIN>
+using android_sink_buf_mt = android_sink<std::mutex, BufferId>;
+template <int BufferId = log_id::LOG_ID_MAIN>
+using android_sink_buf_st = android_sink<details::null_mutex, BufferId>;
+
+} // namespace sinks
+
+// Create and register android syslog logger
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> android_logger_mt(const std::string &logger_name,
+ const std::string &tag = "spdlog") {
+ return Factory::template create<sinks::android_sink_mt>(logger_name, tag);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> android_logger_st(const std::string &logger_name,
+ const std::string &tag = "spdlog") {
+ return Factory::template create<sinks::android_sink_st>(logger_name, tag);
+}
+
+} // namespace spdlog
+
+#endif // __ANDROID__
diff --git a/deps/include/spdlog/sinks/ansicolor_sink-inl.h b/deps/include/spdlog/sinks/ansicolor_sink-inl.h new file mode 100644 index 0000000..1fb2d18 --- /dev/null +++ b/deps/include/spdlog/sinks/ansicolor_sink-inl.h @@ -0,0 +1,135 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+ #include <spdlog/sinks/ansicolor_sink.h>
+#endif
+
+#include <spdlog/details/os.h>
+#include <spdlog/pattern_formatter.h>
+
+namespace spdlog {
+namespace sinks {
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE ansicolor_sink<ConsoleMutex>::ansicolor_sink(FILE *target_file, color_mode mode)
+ : target_file_(target_file),
+ mutex_(ConsoleMutex::mutex()),
+ formatter_(details::make_unique<spdlog::pattern_formatter>())
+
+{
+ set_color_mode(mode);
+ colors_.at(level::trace) = to_string_(white);
+ colors_.at(level::debug) = to_string_(cyan);
+ colors_.at(level::info) = to_string_(green);
+ colors_.at(level::warn) = to_string_(yellow_bold);
+ colors_.at(level::err) = to_string_(red_bold);
+ colors_.at(level::critical) = to_string_(bold_on_red);
+ colors_.at(level::off) = to_string_(reset);
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color(level::level_enum color_level,
+ string_view_t color) {
+ std::lock_guard<mutex_t> lock(mutex_);
+ colors_.at(static_cast<size_t>(color_level)) = to_string_(color);
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::log(const details::log_msg &msg) {
+ // Wrap the originally formatted message in color codes.
+ // If color is not supported in the terminal, log as is instead.
+ std::lock_guard<mutex_t> lock(mutex_);
+ msg.color_range_start = 0;
+ msg.color_range_end = 0;
+ memory_buf_t formatted;
+ formatter_->format(msg, formatted);
+ if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {
+ // before color range
+ print_range_(formatted, 0, msg.color_range_start);
+ // in color range
+ print_ccode_(colors_.at(static_cast<size_t>(msg.level)));
+ print_range_(formatted, msg.color_range_start, msg.color_range_end);
+ print_ccode_(reset);
+ // after color range
+ print_range_(formatted, msg.color_range_end, formatted.size());
+ } else // no color
+ {
+ print_range_(formatted, 0, formatted.size());
+ }
+ fflush(target_file_);
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::flush() {
+ std::lock_guard<mutex_t> lock(mutex_);
+ fflush(target_file_);
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) {
+ std::lock_guard<mutex_t> lock(mutex_);
+ formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_formatter(
+ std::unique_ptr<spdlog::formatter> sink_formatter) {
+ std::lock_guard<mutex_t> lock(mutex_);
+ formatter_ = std::move(sink_formatter);
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE bool ansicolor_sink<ConsoleMutex>::should_color() {
+ return should_do_colors_;
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) {
+ switch (mode) {
+ case color_mode::always:
+ should_do_colors_ = true;
+ return;
+ case color_mode::automatic:
+ should_do_colors_ =
+ details::os::in_terminal(target_file_) && details::os::is_color_terminal();
+ return;
+ case color_mode::never:
+ should_do_colors_ = false;
+ return;
+ default:
+ should_do_colors_ = false;
+ }
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_ccode_(const string_view_t &color_code) {
+ fwrite(color_code.data(), sizeof(char), color_code.size(), target_file_);
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void ansicolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted,
+ size_t start,
+ size_t end) {
+ fwrite(formatted.data() + start, sizeof(char), end - start, target_file_);
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE std::string ansicolor_sink<ConsoleMutex>::to_string_(const string_view_t &sv) {
+ return std::string(sv.data(), sv.size());
+}
+
+// ansicolor_stdout_sink
+template <typename ConsoleMutex>
+SPDLOG_INLINE ansicolor_stdout_sink<ConsoleMutex>::ansicolor_stdout_sink(color_mode mode)
+ : ansicolor_sink<ConsoleMutex>(stdout, mode) {}
+
+// ansicolor_stderr_sink
+template <typename ConsoleMutex>
+SPDLOG_INLINE ansicolor_stderr_sink<ConsoleMutex>::ansicolor_stderr_sink(color_mode mode)
+ : ansicolor_sink<ConsoleMutex>(stderr, mode) {}
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/ansicolor_sink.h b/deps/include/spdlog/sinks/ansicolor_sink.h new file mode 100644 index 0000000..851b2a7 --- /dev/null +++ b/deps/include/spdlog/sinks/ansicolor_sink.h @@ -0,0 +1,115 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <mutex>
+#include <spdlog/details/console_globals.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/sink.h>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+
+/**
+ * This sink prefixes the output with an ANSI escape sequence color code
+ * depending on the severity
+ * of the message.
+ * If no color terminal detected, omit the escape codes.
+ */
+
+template <typename ConsoleMutex>
+class ansicolor_sink : public sink {
+public:
+ using mutex_t = typename ConsoleMutex::mutex_t;
+ ansicolor_sink(FILE *target_file, color_mode mode);
+ ~ansicolor_sink() override = default;
+
+ ansicolor_sink(const ansicolor_sink &other) = delete;
+ ansicolor_sink(ansicolor_sink &&other) = delete;
+
+ ansicolor_sink &operator=(const ansicolor_sink &other) = delete;
+ ansicolor_sink &operator=(ansicolor_sink &&other) = delete;
+
+ void set_color(level::level_enum color_level, string_view_t color);
+ void set_color_mode(color_mode mode);
+ bool should_color();
+
+ void log(const details::log_msg &msg) override;
+ void flush() override;
+ void set_pattern(const std::string &pattern) final override;
+ void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
+
+ // Formatting codes
+ const string_view_t reset = "\033[m";
+ const string_view_t bold = "\033[1m";
+ const string_view_t dark = "\033[2m";
+ const string_view_t underline = "\033[4m";
+ const string_view_t blink = "\033[5m";
+ const string_view_t reverse = "\033[7m";
+ const string_view_t concealed = "\033[8m";
+ const string_view_t clear_line = "\033[K";
+
+ // Foreground colors
+ const string_view_t black = "\033[30m";
+ const string_view_t red = "\033[31m";
+ const string_view_t green = "\033[32m";
+ const string_view_t yellow = "\033[33m";
+ const string_view_t blue = "\033[34m";
+ const string_view_t magenta = "\033[35m";
+ const string_view_t cyan = "\033[36m";
+ const string_view_t white = "\033[37m";
+
+ /// Background colors
+ const string_view_t on_black = "\033[40m";
+ const string_view_t on_red = "\033[41m";
+ const string_view_t on_green = "\033[42m";
+ const string_view_t on_yellow = "\033[43m";
+ const string_view_t on_blue = "\033[44m";
+ const string_view_t on_magenta = "\033[45m";
+ const string_view_t on_cyan = "\033[46m";
+ const string_view_t on_white = "\033[47m";
+
+ /// Bold colors
+ const string_view_t yellow_bold = "\033[33m\033[1m";
+ const string_view_t red_bold = "\033[31m\033[1m";
+ const string_view_t bold_on_red = "\033[1m\033[41m";
+
+private:
+ FILE *target_file_;
+ mutex_t &mutex_;
+ bool should_do_colors_;
+ std::unique_ptr<spdlog::formatter> formatter_;
+ std::array<std::string, level::n_levels> colors_;
+ void print_ccode_(const string_view_t &color_code);
+ void print_range_(const memory_buf_t &formatted, size_t start, size_t end);
+ static std::string to_string_(const string_view_t &sv);
+};
+
+template <typename ConsoleMutex>
+class ansicolor_stdout_sink : public ansicolor_sink<ConsoleMutex> {
+public:
+ explicit ansicolor_stdout_sink(color_mode mode = color_mode::automatic);
+};
+
+template <typename ConsoleMutex>
+class ansicolor_stderr_sink : public ansicolor_sink<ConsoleMutex> {
+public:
+ explicit ansicolor_stderr_sink(color_mode mode = color_mode::automatic);
+};
+
+using ansicolor_stdout_sink_mt = ansicolor_stdout_sink<details::console_mutex>;
+using ansicolor_stdout_sink_st = ansicolor_stdout_sink<details::console_nullmutex>;
+
+using ansicolor_stderr_sink_mt = ansicolor_stderr_sink<details::console_mutex>;
+using ansicolor_stderr_sink_st = ansicolor_stderr_sink<details::console_nullmutex>;
+
+} // namespace sinks
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+ #include "ansicolor_sink-inl.h"
+#endif
diff --git a/deps/include/spdlog/sinks/base_sink-inl.h b/deps/include/spdlog/sinks/base_sink-inl.h new file mode 100644 index 0000000..54ce817 --- /dev/null +++ b/deps/include/spdlog/sinks/base_sink-inl.h @@ -0,0 +1,59 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+ #include <spdlog/sinks/base_sink.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/pattern_formatter.h>
+
+#include <memory>
+#include <mutex>
+
+template <typename Mutex>
+SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink()
+ : formatter_{details::make_unique<spdlog::pattern_formatter>()} {}
+
+template <typename Mutex>
+SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::base_sink(
+ std::unique_ptr<spdlog::formatter> formatter)
+ : formatter_{std::move(formatter)} {}
+
+template <typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::log(const details::log_msg &msg) {
+ std::lock_guard<Mutex> lock(mutex_);
+ sink_it_(msg);
+}
+
+template <typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::flush() {
+ std::lock_guard<Mutex> lock(mutex_);
+ flush_();
+}
+
+template <typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern(const std::string &pattern) {
+ std::lock_guard<Mutex> lock(mutex_);
+ set_pattern_(pattern);
+}
+
+template <typename Mutex>
+void SPDLOG_INLINE
+spdlog::sinks::base_sink<Mutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) {
+ std::lock_guard<Mutex> lock(mutex_);
+ set_formatter_(std::move(sink_formatter));
+}
+
+template <typename Mutex>
+void SPDLOG_INLINE spdlog::sinks::base_sink<Mutex>::set_pattern_(const std::string &pattern) {
+ set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
+}
+
+template <typename Mutex>
+void SPDLOG_INLINE
+spdlog::sinks::base_sink<Mutex>::set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) {
+ formatter_ = std::move(sink_formatter);
+}
diff --git a/deps/include/spdlog/sinks/base_sink.h b/deps/include/spdlog/sinks/base_sink.h new file mode 100644 index 0000000..9b25712 --- /dev/null +++ b/deps/include/spdlog/sinks/base_sink.h @@ -0,0 +1,51 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+//
+// base sink templated over a mutex (either dummy or real)
+// concrete implementation should override the sink_it_() and flush_() methods.
+// locking is taken care of in this class - no locking needed by the
+// implementers..
+//
+
+#include <spdlog/common.h>
+#include <spdlog/details/log_msg.h>
+#include <spdlog/sinks/sink.h>
+
+namespace spdlog {
+namespace sinks {
+template <typename Mutex>
+class SPDLOG_API base_sink : public sink {
+public:
+ base_sink();
+ explicit base_sink(std::unique_ptr<spdlog::formatter> formatter);
+ ~base_sink() override = default;
+
+ base_sink(const base_sink &) = delete;
+ base_sink(base_sink &&) = delete;
+
+ base_sink &operator=(const base_sink &) = delete;
+ base_sink &operator=(base_sink &&) = delete;
+
+ void log(const details::log_msg &msg) final override;
+ void flush() final override;
+ void set_pattern(const std::string &pattern) final override;
+ void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final override;
+
+protected:
+ // sink formatter
+ std::unique_ptr<spdlog::formatter> formatter_;
+ Mutex mutex_;
+
+ virtual void sink_it_(const details::log_msg &msg) = 0;
+ virtual void flush_() = 0;
+ virtual void set_pattern_(const std::string &pattern);
+ virtual void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter);
+};
+} // namespace sinks
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+ #include "base_sink-inl.h"
+#endif
diff --git a/deps/include/spdlog/sinks/basic_file_sink-inl.h b/deps/include/spdlog/sinks/basic_file_sink-inl.h new file mode 100644 index 0000000..658263d --- /dev/null +++ b/deps/include/spdlog/sinks/basic_file_sink-inl.h @@ -0,0 +1,42 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+ #include <spdlog/sinks/basic_file_sink.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+namespace spdlog {
+namespace sinks {
+
+template <typename Mutex>
+SPDLOG_INLINE basic_file_sink<Mutex>::basic_file_sink(const filename_t &filename,
+ bool truncate,
+ const file_event_handlers &event_handlers)
+ : file_helper_{event_handlers} {
+ file_helper_.open(filename, truncate);
+}
+
+template <typename Mutex>
+SPDLOG_INLINE const filename_t &basic_file_sink<Mutex>::filename() const {
+ return file_helper_.filename();
+}
+
+template <typename Mutex>
+SPDLOG_INLINE void basic_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ file_helper_.write(formatted);
+}
+
+template <typename Mutex>
+SPDLOG_INLINE void basic_file_sink<Mutex>::flush_() {
+ file_helper_.flush();
+}
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/basic_file_sink.h b/deps/include/spdlog/sinks/basic_file_sink.h new file mode 100644 index 0000000..205409a --- /dev/null +++ b/deps/include/spdlog/sinks/basic_file_sink.h @@ -0,0 +1,65 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+/*
+ * Trivial file sink with single file as target
+ */
+template <typename Mutex>
+class basic_file_sink final : public base_sink<Mutex> {
+public:
+ explicit basic_file_sink(const filename_t &filename,
+ bool truncate = false,
+ const file_event_handlers &event_handlers = {});
+ const filename_t &filename() const;
+
+protected:
+ void sink_it_(const details::log_msg &msg) override;
+ void flush_() override;
+
+private:
+ details::file_helper file_helper_;
+};
+
+using basic_file_sink_mt = basic_file_sink<std::mutex>;
+using basic_file_sink_st = basic_file_sink<details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> basic_logger_mt(const std::string &logger_name,
+ const filename_t &filename,
+ bool truncate = false,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::basic_file_sink_mt>(logger_name, filename, truncate,
+ event_handlers);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> basic_logger_st(const std::string &logger_name,
+ const filename_t &filename,
+ bool truncate = false,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::basic_file_sink_st>(logger_name, filename, truncate,
+ event_handlers);
+}
+
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+ #include "basic_file_sink-inl.h"
+#endif
diff --git a/deps/include/spdlog/sinks/callback_sink.h b/deps/include/spdlog/sinks/callback_sink.h new file mode 100644 index 0000000..2001ac0 --- /dev/null +++ b/deps/include/spdlog/sinks/callback_sink.h @@ -0,0 +1,56 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+
+// callbacks type
+typedef std::function<void(const details::log_msg &msg)> custom_log_callback;
+
+namespace sinks {
+/*
+ * Trivial callback sink, gets a callback function and calls it on each log
+ */
+template <typename Mutex>
+class callback_sink final : public base_sink<Mutex> {
+public:
+ explicit callback_sink(const custom_log_callback &callback)
+ : callback_{callback} {}
+
+protected:
+ void sink_it_(const details::log_msg &msg) override { callback_(msg); }
+ void flush_() override{}
+
+private:
+ custom_log_callback callback_;
+};
+
+using callback_sink_mt = callback_sink<std::mutex>;
+using callback_sink_st = callback_sink<details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> callback_logger_mt(const std::string &logger_name,
+ const custom_log_callback &callback) {
+ return Factory::template create<sinks::callback_sink_mt>(logger_name, callback);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> callback_logger_st(const std::string &logger_name,
+ const custom_log_callback &callback) {
+ return Factory::template create<sinks::callback_sink_st>(logger_name, callback);
+}
+
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/daily_file_sink.h b/deps/include/spdlog/sinks/daily_file_sink.h new file mode 100644 index 0000000..2bf74fe --- /dev/null +++ b/deps/include/spdlog/sinks/daily_file_sink.h @@ -0,0 +1,255 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/circular_q.h>
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/fmt/chrono.h>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <chrono>
+#include <cstdio>
+#include <iomanip>
+#include <mutex>
+#include <sstream>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+
+/*
+ * Generator of daily log file names in format basename.YYYY-MM-DD.ext
+ */
+struct daily_filename_calculator {
+ // Create filename for the form basename.YYYY-MM-DD
+ static filename_t calc_filename(const filename_t &filename, const tm &now_tm) {
+ filename_t basename, ext;
+ std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
+ return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}{}")),
+ basename, now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
+ ext);
+ }
+};
+
+/*
+ * Generator of daily log file names with strftime format.
+ * Usages:
+ * auto sink =
+ * std::make_shared<spdlog::sinks::daily_file_format_sink_mt>("myapp-%Y-%m-%d:%H:%M:%S.log", hour,
+ * minute);" auto logger = spdlog::daily_logger_format_mt("loggername, "myapp-%Y-%m-%d:%X.log",
+ * hour, minute)"
+ *
+ */
+struct daily_filename_format_calculator {
+ static filename_t calc_filename(const filename_t &file_path, const tm &now_tm) {
+#if defined(_WIN32) && defined(SPDLOG_WCHAR_FILENAMES)
+ std::wstringstream stream;
+#else
+ std::stringstream stream;
+#endif
+ stream << std::put_time(&now_tm, file_path.c_str());
+ return stream.str();
+ }
+};
+
+/*
+ * Rotating file sink based on date.
+ * If truncate != false , the created file will be truncated.
+ * If max_files > 0, retain only the last max_files and delete previous.
+ * If max_files > 0, retain only the last max_files and delete previous.
+ * Note that old log files from previous executions will not be deleted by this class,
+ * rotation and deletion is only applied while the program is running.
+ */
+template <typename Mutex, typename FileNameCalc = daily_filename_calculator>
+class daily_file_sink final : public base_sink<Mutex> {
+public:
+ // create daily file sink which rotates on given time
+ daily_file_sink(filename_t base_filename,
+ int rotation_hour,
+ int rotation_minute,
+ bool truncate = false,
+ uint16_t max_files = 0,
+ const file_event_handlers &event_handlers = {})
+ : base_filename_(std::move(base_filename)),
+ rotation_h_(rotation_hour),
+ rotation_m_(rotation_minute),
+ file_helper_{event_handlers},
+ truncate_(truncate),
+ max_files_(max_files),
+ filenames_q_() {
+ if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 ||
+ rotation_minute > 59) {
+ throw_spdlog_ex("daily_file_sink: Invalid rotation time in ctor");
+ }
+
+ auto now = log_clock::now();
+ auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+ file_helper_.open(filename, truncate_);
+ rotation_tp_ = next_rotation_tp_();
+
+ if (max_files_ > 0) {
+ init_filenames_q_();
+ }
+ }
+
+ filename_t filename() {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ return file_helper_.filename();
+ }
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ auto time = msg.time;
+ bool should_rotate = time >= rotation_tp_;
+ if (should_rotate) {
+ auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));
+ file_helper_.open(filename, truncate_);
+ rotation_tp_ = next_rotation_tp_();
+ }
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ file_helper_.write(formatted);
+
+ // Do the cleaning only at the end because it might throw on failure.
+ if (should_rotate && max_files_ > 0) {
+ delete_old_();
+ }
+ }
+
+ void flush_() override { file_helper_.flush(); }
+
+private:
+ void init_filenames_q_() {
+ using details::os::path_exists;
+
+ filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_));
+ std::vector<filename_t> filenames;
+ auto now = log_clock::now();
+ while (filenames.size() < max_files_) {
+ auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+ if (!path_exists(filename)) {
+ break;
+ }
+ filenames.emplace_back(filename);
+ now -= std::chrono::hours(24);
+ }
+ for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) {
+ filenames_q_.push_back(std::move(*iter));
+ }
+ }
+
+ tm now_tm(log_clock::time_point tp) {
+ time_t tnow = log_clock::to_time_t(tp);
+ return spdlog::details::os::localtime(tnow);
+ }
+
+ log_clock::time_point next_rotation_tp_() {
+ auto now = log_clock::now();
+ tm date = now_tm(now);
+ date.tm_hour = rotation_h_;
+ date.tm_min = rotation_m_;
+ date.tm_sec = 0;
+ auto rotation_time = log_clock::from_time_t(std::mktime(&date));
+ if (rotation_time > now) {
+ return rotation_time;
+ }
+ return {rotation_time + std::chrono::hours(24)};
+ }
+
+ // Delete the file N rotations ago.
+ // Throw spdlog_ex on failure to delete the old file.
+ void delete_old_() {
+ using details::os::filename_to_str;
+ using details::os::remove_if_exists;
+
+ filename_t current_file = file_helper_.filename();
+ if (filenames_q_.full()) {
+ auto old_filename = std::move(filenames_q_.front());
+ filenames_q_.pop_front();
+ bool ok = remove_if_exists(old_filename) == 0;
+ if (!ok) {
+ filenames_q_.push_back(std::move(current_file));
+ throw_spdlog_ex("Failed removing daily file " + filename_to_str(old_filename),
+ errno);
+ }
+ }
+ filenames_q_.push_back(std::move(current_file));
+ }
+
+ filename_t base_filename_;
+ int rotation_h_;
+ int rotation_m_;
+ log_clock::time_point rotation_tp_;
+ details::file_helper file_helper_;
+ bool truncate_;
+ uint16_t max_files_;
+ details::circular_q<filename_t> filenames_q_;
+};
+
+using daily_file_sink_mt = daily_file_sink<std::mutex>;
+using daily_file_sink_st = daily_file_sink<details::null_mutex>;
+using daily_file_format_sink_mt = daily_file_sink<std::mutex, daily_filename_format_calculator>;
+using daily_file_format_sink_st =
+ daily_file_sink<details::null_mutex, daily_filename_format_calculator>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> daily_logger_mt(const std::string &logger_name,
+ const filename_t &filename,
+ int hour = 0,
+ int minute = 0,
+ bool truncate = false,
+ uint16_t max_files = 0,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::daily_file_sink_mt>(logger_name, filename, hour, minute,
+ truncate, max_files, event_handlers);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> daily_logger_format_mt(
+ const std::string &logger_name,
+ const filename_t &filename,
+ int hour = 0,
+ int minute = 0,
+ bool truncate = false,
+ uint16_t max_files = 0,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::daily_file_format_sink_mt>(
+ logger_name, filename, hour, minute, truncate, max_files, event_handlers);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> daily_logger_st(const std::string &logger_name,
+ const filename_t &filename,
+ int hour = 0,
+ int minute = 0,
+ bool truncate = false,
+ uint16_t max_files = 0,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::daily_file_sink_st>(logger_name, filename, hour, minute,
+ truncate, max_files, event_handlers);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> daily_logger_format_st(
+ const std::string &logger_name,
+ const filename_t &filename,
+ int hour = 0,
+ int minute = 0,
+ bool truncate = false,
+ uint16_t max_files = 0,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::daily_file_format_sink_st>(
+ logger_name, filename, hour, minute, truncate, max_files, event_handlers);
+}
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/dist_sink.h b/deps/include/spdlog/sinks/dist_sink.h new file mode 100644 index 0000000..1e80a49 --- /dev/null +++ b/deps/include/spdlog/sinks/dist_sink.h @@ -0,0 +1,81 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "base_sink.h"
+#include <spdlog/details/log_msg.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/pattern_formatter.h>
+
+#include <algorithm>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+// Distribution sink (mux). Stores a vector of sinks which get called when log
+// is called
+
+namespace spdlog {
+namespace sinks {
+
+template <typename Mutex>
+class dist_sink : public base_sink<Mutex> {
+public:
+ dist_sink() = default;
+ explicit dist_sink(std::vector<std::shared_ptr<sink>> sinks)
+ : sinks_(sinks) {}
+
+ dist_sink(const dist_sink &) = delete;
+ dist_sink &operator=(const dist_sink &) = delete;
+
+ void add_sink(std::shared_ptr<sink> sub_sink) {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ sinks_.push_back(sub_sink);
+ }
+
+ void remove_sink(std::shared_ptr<sink> sub_sink) {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ sinks_.erase(std::remove(sinks_.begin(), sinks_.end(), sub_sink), sinks_.end());
+ }
+
+ void set_sinks(std::vector<std::shared_ptr<sink>> sinks) {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ sinks_ = std::move(sinks);
+ }
+
+ std::vector<std::shared_ptr<sink>> &sinks() { return sinks_; }
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ for (auto &sub_sink : sinks_) {
+ if (sub_sink->should_log(msg.level)) {
+ sub_sink->log(msg);
+ }
+ }
+ }
+
+ void flush_() override {
+ for (auto &sub_sink : sinks_) {
+ sub_sink->flush();
+ }
+ }
+
+ void set_pattern_(const std::string &pattern) override {
+ set_formatter_(details::make_unique<spdlog::pattern_formatter>(pattern));
+ }
+
+ void set_formatter_(std::unique_ptr<spdlog::formatter> sink_formatter) override {
+ base_sink<Mutex>::formatter_ = std::move(sink_formatter);
+ for (auto &sub_sink : sinks_) {
+ sub_sink->set_formatter(base_sink<Mutex>::formatter_->clone());
+ }
+ }
+ std::vector<std::shared_ptr<sink>> sinks_;
+};
+
+using dist_sink_mt = dist_sink<std::mutex>;
+using dist_sink_st = dist_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/dup_filter_sink.h b/deps/include/spdlog/sinks/dup_filter_sink.h new file mode 100644 index 0000000..1ac9849 --- /dev/null +++ b/deps/include/spdlog/sinks/dup_filter_sink.h @@ -0,0 +1,92 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "dist_sink.h"
+#include <spdlog/details/log_msg.h>
+#include <spdlog/details/null_mutex.h>
+
+#include <chrono>
+#include <cstdio>
+#include <mutex>
+#include <string>
+
+// Duplicate message removal sink.
+// Skip the message if previous one is identical and less than "max_skip_duration" have passed
+//
+// Example:
+//
+// #include <spdlog/sinks/dup_filter_sink.h>
+//
+// int main() {
+// auto dup_filter = std::make_shared<dup_filter_sink_st>(std::chrono::seconds(5),
+// level::info); dup_filter->add_sink(std::make_shared<stdout_color_sink_mt>());
+// spdlog::logger l("logger", dup_filter);
+// l.info("Hello");
+// l.info("Hello");
+// l.info("Hello");
+// l.info("Different Hello");
+// }
+//
+// Will produce:
+// [2019-06-25 17:50:56.511] [logger] [info] Hello
+// [2019-06-25 17:50:56.512] [logger] [info] Skipped 3 duplicate messages..
+// [2019-06-25 17:50:56.512] [logger] [info] Different Hello
+
+namespace spdlog {
+namespace sinks {
+template <typename Mutex>
+class dup_filter_sink : public dist_sink<Mutex> {
+public:
+ template <class Rep, class Period>
+ explicit dup_filter_sink(std::chrono::duration<Rep, Period> max_skip_duration,
+ level::level_enum notification_level = level::info)
+ : max_skip_duration_{max_skip_duration},
+ log_level_{notification_level} {}
+
+protected:
+ std::chrono::microseconds max_skip_duration_;
+ log_clock::time_point last_msg_time_;
+ std::string last_msg_payload_;
+ size_t skip_counter_ = 0;
+ level::level_enum log_level_;
+
+ void sink_it_(const details::log_msg &msg) override {
+ bool filtered = filter_(msg);
+ if (!filtered) {
+ skip_counter_ += 1;
+ return;
+ }
+
+ // log the "skipped.." message
+ if (skip_counter_ > 0) {
+ char buf[64];
+ auto msg_size = ::snprintf(buf, sizeof(buf), "Skipped %u duplicate messages..",
+ static_cast<unsigned>(skip_counter_));
+ if (msg_size > 0 && static_cast<size_t>(msg_size) < sizeof(buf)) {
+ details::log_msg skipped_msg{msg.source, msg.logger_name, log_level_,
+ string_view_t{buf, static_cast<size_t>(msg_size)}};
+ dist_sink<Mutex>::sink_it_(skipped_msg);
+ }
+ }
+
+ // log current message
+ dist_sink<Mutex>::sink_it_(msg);
+ last_msg_time_ = msg.time;
+ skip_counter_ = 0;
+ last_msg_payload_.assign(msg.payload.data(), msg.payload.data() + msg.payload.size());
+ }
+
+ // return whether the log msg should be displayed (true) or skipped (false)
+ bool filter_(const details::log_msg &msg) {
+ auto filter_duration = msg.time - last_msg_time_;
+ return (filter_duration > max_skip_duration_) || (msg.payload != last_msg_payload_);
+ }
+};
+
+using dup_filter_sink_mt = dup_filter_sink<std::mutex>;
+using dup_filter_sink_st = dup_filter_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/hourly_file_sink.h b/deps/include/spdlog/sinks/hourly_file_sink.h new file mode 100644 index 0000000..b264d2a --- /dev/null +++ b/deps/include/spdlog/sinks/hourly_file_sink.h @@ -0,0 +1,193 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/circular_q.h>
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/fmt/fmt.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <chrono>
+#include <cstdio>
+#include <ctime>
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+
+/*
+ * Generator of Hourly log file names in format basename.YYYY-MM-DD-HH.ext
+ */
+struct hourly_filename_calculator {
+ // Create filename for the form basename.YYYY-MM-DD-H
+ static filename_t calc_filename(const filename_t &filename, const tm &now_tm) {
+ filename_t basename, ext;
+ std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
+ return fmt_lib::format(SPDLOG_FILENAME_T("{}_{:04d}-{:02d}-{:02d}_{:02d}{}"), basename,
+ now_tm.tm_year + 1900, now_tm.tm_mon + 1, now_tm.tm_mday,
+ now_tm.tm_hour, ext);
+ }
+};
+
+/*
+ * Rotating file sink based on time.
+ * If truncate != false , the created file will be truncated.
+ * If max_files > 0, retain only the last max_files and delete previous.
+ * Note that old log files from previous executions will not be deleted by this class,
+ * rotation and deletion is only applied while the program is running.
+ */
+template <typename Mutex, typename FileNameCalc = hourly_filename_calculator>
+class hourly_file_sink final : public base_sink<Mutex> {
+public:
+ // create hourly file sink which rotates on given time
+ hourly_file_sink(filename_t base_filename,
+ bool truncate = false,
+ uint16_t max_files = 0,
+ const file_event_handlers &event_handlers = {})
+ : base_filename_(std::move(base_filename)),
+ file_helper_{event_handlers},
+ truncate_(truncate),
+ max_files_(max_files),
+ filenames_q_() {
+ auto now = log_clock::now();
+ auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+ file_helper_.open(filename, truncate_);
+ remove_init_file_ = file_helper_.size() == 0;
+ rotation_tp_ = next_rotation_tp_();
+
+ if (max_files_ > 0) {
+ init_filenames_q_();
+ }
+ }
+
+ filename_t filename() {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ return file_helper_.filename();
+ }
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ auto time = msg.time;
+ bool should_rotate = time >= rotation_tp_;
+ if (should_rotate) {
+ if (remove_init_file_) {
+ file_helper_.close();
+ details::os::remove(file_helper_.filename());
+ }
+ auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(time));
+ file_helper_.open(filename, truncate_);
+ rotation_tp_ = next_rotation_tp_();
+ }
+ remove_init_file_ = false;
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ file_helper_.write(formatted);
+
+ // Do the cleaning only at the end because it might throw on failure.
+ if (should_rotate && max_files_ > 0) {
+ delete_old_();
+ }
+ }
+
+ void flush_() override { file_helper_.flush(); }
+
+private:
+ void init_filenames_q_() {
+ using details::os::path_exists;
+
+ filenames_q_ = details::circular_q<filename_t>(static_cast<size_t>(max_files_));
+ std::vector<filename_t> filenames;
+ auto now = log_clock::now();
+ while (filenames.size() < max_files_) {
+ auto filename = FileNameCalc::calc_filename(base_filename_, now_tm(now));
+ if (!path_exists(filename)) {
+ break;
+ }
+ filenames.emplace_back(filename);
+ now -= std::chrono::hours(1);
+ }
+ for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) {
+ filenames_q_.push_back(std::move(*iter));
+ }
+ }
+
+ tm now_tm(log_clock::time_point tp) {
+ time_t tnow = log_clock::to_time_t(tp);
+ return spdlog::details::os::localtime(tnow);
+ }
+
+ log_clock::time_point next_rotation_tp_() {
+ auto now = log_clock::now();
+ tm date = now_tm(now);
+ date.tm_min = 0;
+ date.tm_sec = 0;
+ auto rotation_time = log_clock::from_time_t(std::mktime(&date));
+ if (rotation_time > now) {
+ return rotation_time;
+ }
+ return {rotation_time + std::chrono::hours(1)};
+ }
+
+ // Delete the file N rotations ago.
+ // Throw spdlog_ex on failure to delete the old file.
+ void delete_old_() {
+ using details::os::filename_to_str;
+ using details::os::remove_if_exists;
+
+ filename_t current_file = file_helper_.filename();
+ if (filenames_q_.full()) {
+ auto old_filename = std::move(filenames_q_.front());
+ filenames_q_.pop_front();
+ bool ok = remove_if_exists(old_filename) == 0;
+ if (!ok) {
+ filenames_q_.push_back(std::move(current_file));
+ SPDLOG_THROW(spdlog_ex(
+ "Failed removing hourly file " + filename_to_str(old_filename), errno));
+ }
+ }
+ filenames_q_.push_back(std::move(current_file));
+ }
+
+ filename_t base_filename_;
+ log_clock::time_point rotation_tp_;
+ details::file_helper file_helper_;
+ bool truncate_;
+ uint16_t max_files_;
+ details::circular_q<filename_t> filenames_q_;
+ bool remove_init_file_;
+};
+
+using hourly_file_sink_mt = hourly_file_sink<std::mutex>;
+using hourly_file_sink_st = hourly_file_sink<details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> hourly_logger_mt(const std::string &logger_name,
+ const filename_t &filename,
+ bool truncate = false,
+ uint16_t max_files = 0,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::hourly_file_sink_mt>(logger_name, filename, truncate,
+ max_files, event_handlers);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> hourly_logger_st(const std::string &logger_name,
+ const filename_t &filename,
+ bool truncate = false,
+ uint16_t max_files = 0,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::hourly_file_sink_st>(logger_name, filename, truncate,
+ max_files, event_handlers);
+}
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/kafka_sink.h b/deps/include/spdlog/sinks/kafka_sink.h new file mode 100644 index 0000000..2c4281b --- /dev/null +++ b/deps/include/spdlog/sinks/kafka_sink.h @@ -0,0 +1,119 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+//
+// Custom sink for kafka
+// Building and using requires librdkafka library.
+// For building librdkafka library check the url below
+// https://github.com/confluentinc/librdkafka
+//
+
+#include "spdlog/async.h"
+#include "spdlog/details/log_msg.h"
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/details/synchronous_factory.h"
+#include "spdlog/sinks/base_sink.h"
+#include <mutex>
+#include <spdlog/common.h>
+
+// kafka header
+#include <librdkafka/rdkafkacpp.h>
+
+namespace spdlog {
+namespace sinks {
+
+struct kafka_sink_config {
+ std::string server_addr;
+ std::string produce_topic;
+ int32_t flush_timeout_ms = 1000;
+
+ kafka_sink_config(std::string addr, std::string topic, int flush_timeout_ms = 1000)
+ : server_addr{std::move(addr)},
+ produce_topic{std::move(topic)},
+ flush_timeout_ms(flush_timeout_ms) {}
+};
+
+template <typename Mutex>
+class kafka_sink : public base_sink<Mutex> {
+public:
+ kafka_sink(kafka_sink_config config)
+ : config_{std::move(config)} {
+ try {
+ std::string errstr;
+ conf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_GLOBAL));
+ RdKafka::Conf::ConfResult confRes =
+ conf_->set("bootstrap.servers", config_.server_addr, errstr);
+ if (confRes != RdKafka::Conf::CONF_OK) {
+ throw_spdlog_ex(
+ fmt_lib::format("conf set bootstrap.servers failed err:{}", errstr));
+ }
+
+ tconf_.reset(RdKafka::Conf::create(RdKafka::Conf::CONF_TOPIC));
+ if (tconf_ == nullptr) {
+ throw_spdlog_ex(fmt_lib::format("create topic config failed"));
+ }
+
+ producer_.reset(RdKafka::Producer::create(conf_.get(), errstr));
+ if (producer_ == nullptr) {
+ throw_spdlog_ex(fmt_lib::format("create producer failed err:{}", errstr));
+ }
+ topic_.reset(RdKafka::Topic::create(producer_.get(), config_.produce_topic,
+ tconf_.get(), errstr));
+ if (topic_ == nullptr) {
+ throw_spdlog_ex(fmt_lib::format("create topic failed err:{}", errstr));
+ }
+ } catch (const std::exception &e) {
+ throw_spdlog_ex(fmt_lib::format("error create kafka instance: {}", e.what()));
+ }
+ }
+
+ ~kafka_sink() { producer_->flush(config_.flush_timeout_ms); }
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ producer_->produce(topic_.get(), 0, RdKafka::Producer::RK_MSG_COPY,
+ (void *)msg.payload.data(), msg.payload.size(), NULL, NULL);
+ }
+
+ void flush_() override { producer_->flush(config_.flush_timeout_ms); }
+
+private:
+ kafka_sink_config config_;
+ std::unique_ptr<RdKafka::Producer> producer_ = nullptr;
+ std::unique_ptr<RdKafka::Conf> conf_ = nullptr;
+ std::unique_ptr<RdKafka::Conf> tconf_ = nullptr;
+ std::unique_ptr<RdKafka::Topic> topic_ = nullptr;
+};
+
+using kafka_sink_mt = kafka_sink<std::mutex>;
+using kafka_sink_st = kafka_sink<spdlog::details::null_mutex>;
+
+} // namespace sinks
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> kafka_logger_mt(const std::string &logger_name,
+ spdlog::sinks::kafka_sink_config config) {
+ return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> kafka_logger_st(const std::string &logger_name,
+ spdlog::sinks::kafka_sink_config config) {
+ return Factory::template create<sinks::kafka_sink_st>(logger_name, config);
+}
+
+template <typename Factory = spdlog::async_factory>
+inline std::shared_ptr<spdlog::logger> kafka_logger_async_mt(
+ std::string logger_name, spdlog::sinks::kafka_sink_config config) {
+ return Factory::template create<sinks::kafka_sink_mt>(logger_name, config);
+}
+
+template <typename Factory = spdlog::async_factory>
+inline std::shared_ptr<spdlog::logger> kafka_logger_async_st(
+ std::string logger_name, spdlog::sinks::kafka_sink_config config) {
+ return Factory::template create<sinks::kafka_sink_st>(logger_name, config);
+}
+
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/mongo_sink.h b/deps/include/spdlog/sinks/mongo_sink.h new file mode 100644 index 0000000..cc98801 --- /dev/null +++ b/deps/include/spdlog/sinks/mongo_sink.h @@ -0,0 +1,108 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+//
+// Custom sink for mongodb
+// Building and using requires mongocxx library.
+// For building mongocxx library check the url below
+// http://mongocxx.org/mongocxx-v3/installation/
+//
+
+#include "spdlog/common.h"
+#include "spdlog/details/log_msg.h"
+#include "spdlog/sinks/base_sink.h"
+#include <spdlog/details/synchronous_factory.h>
+
+#include <bsoncxx/builder/stream/document.hpp>
+#include <bsoncxx/types.hpp>
+#include <bsoncxx/view_or_value.hpp>
+
+#include <mongocxx/client.hpp>
+#include <mongocxx/instance.hpp>
+#include <mongocxx/uri.hpp>
+
+namespace spdlog {
+namespace sinks {
+template <typename Mutex>
+class mongo_sink : public base_sink<Mutex> {
+public:
+ mongo_sink(const std::string &db_name,
+ const std::string &collection_name,
+ const std::string &uri = "mongodb://localhost:27017") try
+ : mongo_sink(std::make_shared<mongocxx::instance>(), db_name, collection_name, uri) {
+ } catch (const std::exception &e) {
+ throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
+ }
+
+ mongo_sink(std::shared_ptr<mongocxx::instance> instance,
+ const std::string &db_name,
+ const std::string &collection_name,
+ const std::string &uri = "mongodb://localhost:27017")
+ : instance_(std::move(instance)),
+ db_name_(db_name),
+ coll_name_(collection_name) {
+ try {
+ client_ = spdlog::details::make_unique<mongocxx::client>(mongocxx::uri{uri});
+ } catch (const std::exception &e) {
+ throw_spdlog_ex(fmt_lib::format("Error opening database: {}", e.what()));
+ }
+ }
+
+ ~mongo_sink() { flush_(); }
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ using bsoncxx::builder::stream::document;
+ using bsoncxx::builder::stream::finalize;
+
+ if (client_ != nullptr) {
+ auto doc = document{} << "timestamp" << bsoncxx::types::b_date(msg.time) << "level"
+ << level::to_string_view(msg.level).data() << "level_num"
+ << msg.level << "message"
+ << std::string(msg.payload.begin(), msg.payload.end())
+ << "logger_name"
+ << std::string(msg.logger_name.begin(), msg.logger_name.end())
+ << "thread_id" << static_cast<int>(msg.thread_id) << finalize;
+ client_->database(db_name_).collection(coll_name_).insert_one(doc.view());
+ }
+ }
+
+ void flush_() override {}
+
+private:
+ std::shared_ptr<mongocxx::instance> instance_;
+ std::string db_name_;
+ std::string coll_name_;
+ std::unique_ptr<mongocxx::client> client_ = nullptr;
+};
+
+#include "spdlog/details/null_mutex.h"
+#include <mutex>
+using mongo_sink_mt = mongo_sink<std::mutex>;
+using mongo_sink_st = mongo_sink<spdlog::details::null_mutex>;
+
+} // namespace sinks
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> mongo_logger_mt(
+ const std::string &logger_name,
+ const std::string &db_name,
+ const std::string &collection_name,
+ const std::string &uri = "mongodb://localhost:27017") {
+ return Factory::template create<sinks::mongo_sink_mt>(logger_name, db_name, collection_name,
+ uri);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> mongo_logger_st(
+ const std::string &logger_name,
+ const std::string &db_name,
+ const std::string &collection_name,
+ const std::string &uri = "mongodb://localhost:27017") {
+ return Factory::template create<sinks::mongo_sink_st>(logger_name, db_name, collection_name,
+ uri);
+}
+
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/msvc_sink.h b/deps/include/spdlog/sinks/msvc_sink.h new file mode 100644 index 0000000..2b5d5b8 --- /dev/null +++ b/deps/include/spdlog/sinks/msvc_sink.h @@ -0,0 +1,68 @@ +// Copyright(c) 2016 Alexander Dalshov & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#if defined(_WIN32)
+
+ #include <spdlog/details/null_mutex.h>
+ #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+ #include <spdlog/details/os.h>
+ #endif
+ #include <spdlog/sinks/base_sink.h>
+
+ #include <mutex>
+ #include <string>
+
+ // Avoid including windows.h (https://stackoverflow.com/a/30741042)
+ #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+extern "C" __declspec(dllimport) void __stdcall OutputDebugStringW(const wchar_t *lpOutputString);
+ #else
+extern "C" __declspec(dllimport) void __stdcall OutputDebugStringA(const char *lpOutputString);
+ #endif
+extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+
+namespace spdlog {
+namespace sinks {
+/*
+ * MSVC sink (logging using OutputDebugStringA)
+ */
+template <typename Mutex>
+class msvc_sink : public base_sink<Mutex> {
+public:
+ msvc_sink() = default;
+ msvc_sink(bool check_debugger_present)
+ : check_debugger_present_{check_debugger_present} {}
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ if (check_debugger_present_ && !IsDebuggerPresent()) {
+ return;
+ }
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ formatted.push_back('\0'); // add a null terminator for OutputDebugString
+ #if defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT)
+ wmemory_buf_t wformatted;
+ details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), wformatted);
+ OutputDebugStringW(wformatted.data());
+ #else
+ OutputDebugStringA(formatted.data());
+ #endif
+ }
+
+ void flush_() override {}
+
+ bool check_debugger_present_ = true;
+};
+
+using msvc_sink_mt = msvc_sink<std::mutex>;
+using msvc_sink_st = msvc_sink<details::null_mutex>;
+
+using windebug_sink_mt = msvc_sink_mt;
+using windebug_sink_st = msvc_sink_st;
+
+} // namespace sinks
+} // namespace spdlog
+
+#endif
diff --git a/deps/include/spdlog/sinks/null_sink.h b/deps/include/spdlog/sinks/null_sink.h new file mode 100644 index 0000000..4262af3 --- /dev/null +++ b/deps/include/spdlog/sinks/null_sink.h @@ -0,0 +1,41 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <mutex>
+
+namespace spdlog {
+namespace sinks {
+
+template <typename Mutex>
+class null_sink : public base_sink<Mutex> {
+protected:
+ void sink_it_(const details::log_msg &) override {}
+ void flush_() override {}
+};
+
+using null_sink_mt = null_sink<details::null_mutex>;
+using null_sink_st = null_sink<details::null_mutex>;
+
+} // namespace sinks
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> null_logger_mt(const std::string &logger_name) {
+ auto null_logger = Factory::template create<sinks::null_sink_mt>(logger_name);
+ null_logger->set_level(level::off);
+ return null_logger;
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> null_logger_st(const std::string &logger_name) {
+ auto null_logger = Factory::template create<sinks::null_sink_st>(logger_name);
+ null_logger->set_level(level::off);
+ return null_logger;
+}
+
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/ostream_sink.h b/deps/include/spdlog/sinks/ostream_sink.h new file mode 100644 index 0000000..659b4c1 --- /dev/null +++ b/deps/include/spdlog/sinks/ostream_sink.h @@ -0,0 +1,43 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <mutex>
+#include <ostream>
+
+namespace spdlog {
+namespace sinks {
+template <typename Mutex>
+class ostream_sink final : public base_sink<Mutex> {
+public:
+ explicit ostream_sink(std::ostream &os, bool force_flush = false)
+ : ostream_(os),
+ force_flush_(force_flush) {}
+ ostream_sink(const ostream_sink &) = delete;
+ ostream_sink &operator=(const ostream_sink &) = delete;
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ ostream_.write(formatted.data(), static_cast<std::streamsize>(formatted.size()));
+ if (force_flush_) {
+ ostream_.flush();
+ }
+ }
+
+ void flush_() override { ostream_.flush(); }
+
+ std::ostream &ostream_;
+ bool force_flush_;
+};
+
+using ostream_sink_mt = ostream_sink<std::mutex>;
+using ostream_sink_st = ostream_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/qt_sinks.h b/deps/include/spdlog/sinks/qt_sinks.h new file mode 100644 index 0000000..5e10455 --- /dev/null +++ b/deps/include/spdlog/sinks/qt_sinks.h @@ -0,0 +1,304 @@ +// Copyright(c) 2015-present, Gabi Melman, mguludag and spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+//
+// Custom sink for QPlainTextEdit or QTextEdit and its children (QTextBrowser...
+// etc) Building and using requires Qt library.
+//
+// Warning: the qt_sink won't be notified if the target widget is destroyed.
+// If the widget's lifetime can be shorter than the logger's one, you should provide some permanent
+// QObject, and then use a standard signal/slot.
+//
+
+#include "spdlog/common.h"
+#include "spdlog/details/log_msg.h"
+#include "spdlog/details/synchronous_factory.h"
+#include "spdlog/sinks/base_sink.h"
+#include <array>
+
+#include <QPlainTextEdit>
+#include <QTextEdit>
+
+//
+// qt_sink class
+//
+namespace spdlog {
+namespace sinks {
+template <typename Mutex>
+class qt_sink : public base_sink<Mutex> {
+public:
+ qt_sink(QObject *qt_object, std::string meta_method)
+ : qt_object_(qt_object),
+ meta_method_(std::move(meta_method)) {
+ if (!qt_object_) {
+ throw_spdlog_ex("qt_sink: qt_object is null");
+ }
+ }
+
+ ~qt_sink() { flush_(); }
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ const string_view_t str = string_view_t(formatted.data(), formatted.size());
+ QMetaObject::invokeMethod(
+ qt_object_, meta_method_.c_str(), Qt::AutoConnection,
+ Q_ARG(QString, QString::fromUtf8(str.data(), static_cast<int>(str.size())).trimmed()));
+ }
+
+ void flush_() override {}
+
+private:
+ QObject *qt_object_ = nullptr;
+ std::string meta_method_;
+};
+
+// Qt color sink to QTextEdit.
+// Color location is determined by the sink log pattern like in the rest of spdlog sinks.
+// Colors can be modified if needed using sink->set_color(level, qtTextCharFormat).
+// max_lines is the maximum number of lines that the sink will hold before removing the oldest
+// lines. By default, only ascii (latin1) is supported by this sink. Set is_utf8 to true if utf8
+// support is needed.
+template <typename Mutex>
+class qt_color_sink : public base_sink<Mutex> {
+public:
+ qt_color_sink(QTextEdit *qt_text_edit,
+ int max_lines,
+ bool dark_colors = false,
+ bool is_utf8 = false)
+ : qt_text_edit_(qt_text_edit),
+ max_lines_(max_lines),
+ is_utf8_(is_utf8) {
+ if (!qt_text_edit_) {
+ throw_spdlog_ex("qt_color_text_sink: text_edit is null");
+ }
+
+ default_color_ = qt_text_edit_->currentCharFormat();
+ // set colors
+ QTextCharFormat format;
+ // trace
+ format.setForeground(dark_colors ? Qt::darkGray : Qt::gray);
+ colors_.at(level::trace) = format;
+ // debug
+ format.setForeground(dark_colors ? Qt::darkCyan : Qt::cyan);
+ colors_.at(level::debug) = format;
+ // info
+ format.setForeground(dark_colors ? Qt::darkGreen : Qt::green);
+ colors_.at(level::info) = format;
+ // warn
+ format.setForeground(dark_colors ? Qt::darkYellow : Qt::yellow);
+ colors_.at(level::warn) = format;
+ // err
+ format.setForeground(Qt::red);
+ colors_.at(level::err) = format;
+ // critical
+ format.setForeground(Qt::white);
+ format.setBackground(Qt::red);
+ colors_.at(level::critical) = format;
+ }
+
+ ~qt_color_sink() { flush_(); }
+
+ void set_default_color(QTextCharFormat format) {
+ // std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ default_color_ = format;
+ }
+
+ void set_level_color(level::level_enum color_level, QTextCharFormat format) {
+ // std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ colors_.at(static_cast<size_t>(color_level)) = format;
+ }
+
+ QTextCharFormat &get_level_color(level::level_enum color_level) {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ return colors_.at(static_cast<size_t>(color_level));
+ }
+
+ QTextCharFormat &get_default_color() {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ return default_color_;
+ }
+
+protected:
+ struct invoke_params {
+ invoke_params(int max_lines,
+ QTextEdit *q_text_edit,
+ QString payload,
+ QTextCharFormat default_color,
+ QTextCharFormat level_color,
+ int color_range_start,
+ int color_range_end)
+ : max_lines(max_lines),
+ q_text_edit(q_text_edit),
+ payload(std::move(payload)),
+ default_color(default_color),
+ level_color(level_color),
+ color_range_start(color_range_start),
+ color_range_end(color_range_end) {}
+ int max_lines;
+ QTextEdit *q_text_edit;
+ QString payload;
+ QTextCharFormat default_color;
+ QTextCharFormat level_color;
+ int color_range_start;
+ int color_range_end;
+ };
+
+ void sink_it_(const details::log_msg &msg) override {
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+
+ const string_view_t str = string_view_t(formatted.data(), formatted.size());
+ // apply the color to the color range in the formatted message.
+ QString payload;
+ int color_range_start = static_cast<int>(msg.color_range_start);
+ int color_range_end = static_cast<int>(msg.color_range_end);
+ if (is_utf8_) {
+ payload = QString::fromUtf8(str.data(), static_cast<int>(str.size()));
+ // convert color ranges from byte index to character index.
+ if (msg.color_range_start < msg.color_range_end) {
+ color_range_start = QString::fromUtf8(str.data(), msg.color_range_start).size();
+ color_range_end = QString::fromUtf8(str.data(), msg.color_range_end).size();
+ }
+ } else {
+ payload = QString::fromLatin1(str.data(), static_cast<int>(str.size()));
+ }
+
+ invoke_params params{max_lines_, // max lines
+ qt_text_edit_, // text edit to append to
+ std::move(payload), // text to append
+ default_color_, // default color
+ colors_.at(msg.level), // color to apply
+ color_range_start, // color range start
+ color_range_end}; // color range end
+
+ QMetaObject::invokeMethod(
+ qt_text_edit_, [params]() { invoke_method_(params); }, Qt::AutoConnection);
+ }
+
+ void flush_() override {}
+
+ // Add colored text to the text edit widget. This method is invoked in the GUI thread.
+ // It is a static method to ensure that it is handled correctly even if the sink is destroyed
+ // prematurely before it is invoked.
+
+ static void invoke_method_(invoke_params params) {
+ auto *document = params.q_text_edit->document();
+ QTextCursor cursor(document);
+
+ // remove first blocks if number of blocks exceeds max_lines
+ while (document->blockCount() > params.max_lines) {
+ cursor.select(QTextCursor::BlockUnderCursor);
+ cursor.removeSelectedText();
+ cursor.deleteChar(); // delete the newline after the block
+ }
+
+ cursor.movePosition(QTextCursor::End);
+ cursor.setCharFormat(params.default_color);
+
+ // if color range not specified or not not valid, just append the text with default color
+ if (params.color_range_end <= params.color_range_start) {
+ cursor.insertText(params.payload);
+ return;
+ }
+
+ // insert the text before the color range
+ cursor.insertText(params.payload.left(params.color_range_start));
+
+ // insert the colorized text
+ cursor.setCharFormat(params.level_color);
+ cursor.insertText(params.payload.mid(params.color_range_start,
+ params.color_range_end - params.color_range_start));
+
+ // insert the text after the color range with default format
+ cursor.setCharFormat(params.default_color);
+ cursor.insertText(params.payload.mid(params.color_range_end));
+ }
+
+ QTextEdit *qt_text_edit_;
+ int max_lines_;
+ bool is_utf8_;
+ QTextCharFormat default_color_;
+ std::array<QTextCharFormat, level::n_levels> colors_;
+};
+
+#include "spdlog/details/null_mutex.h"
+#include <mutex>
+
+using qt_sink_mt = qt_sink<std::mutex>;
+using qt_sink_st = qt_sink<details::null_mutex>;
+using qt_color_sink_mt = qt_color_sink<std::mutex>;
+using qt_color_sink_st = qt_color_sink<details::null_mutex>;
+} // namespace sinks
+
+//
+// Factory functions
+//
+
+// log to QTextEdit
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name,
+ QTextEdit *qt_object,
+ const std::string &meta_method = "append") {
+ return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
+ QTextEdit *qt_object,
+ const std::string &meta_method = "append") {
+ return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
+}
+
+// log to QPlainTextEdit
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name,
+ QPlainTextEdit *qt_object,
+ const std::string &meta_method = "appendPlainText") {
+ return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
+ QPlainTextEdit *qt_object,
+ const std::string &meta_method = "appendPlainText") {
+ return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
+}
+// log to QObject
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_mt(const std::string &logger_name,
+ QObject *qt_object,
+ const std::string &meta_method) {
+ return Factory::template create<sinks::qt_sink_mt>(logger_name, qt_object, meta_method);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_logger_st(const std::string &logger_name,
+ QObject *qt_object,
+ const std::string &meta_method) {
+ return Factory::template create<sinks::qt_sink_st>(logger_name, qt_object, meta_method);
+}
+
+// log to QTextEdit with colorized output
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_color_logger_mt(const std::string &logger_name,
+ QTextEdit *qt_text_edit,
+ int max_lines,
+ bool is_utf8 = false) {
+ return Factory::template create<sinks::qt_color_sink_mt>(logger_name, qt_text_edit, max_lines,
+ false, is_utf8);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> qt_color_logger_st(const std::string &logger_name,
+ QTextEdit *qt_text_edit,
+ int max_lines,
+ bool is_utf8 = false) {
+ return Factory::template create<sinks::qt_color_sink_st>(logger_name, qt_text_edit, max_lines,
+ false, is_utf8);
+}
+
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/ringbuffer_sink.h b/deps/include/spdlog/sinks/ringbuffer_sink.h new file mode 100644 index 0000000..34bbd71 --- /dev/null +++ b/deps/include/spdlog/sinks/ringbuffer_sink.h @@ -0,0 +1,67 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include "spdlog/details/circular_q.h"
+#include "spdlog/details/log_msg_buffer.h"
+#include "spdlog/details/null_mutex.h"
+#include "spdlog/sinks/base_sink.h"
+
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace spdlog {
+namespace sinks {
+/*
+ * Ring buffer sink
+ */
+template <typename Mutex>
+class ringbuffer_sink final : public base_sink<Mutex> {
+public:
+ explicit ringbuffer_sink(size_t n_items)
+ : q_{n_items} {}
+
+ std::vector<details::log_msg_buffer> last_raw(size_t lim = 0) {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ auto items_available = q_.size();
+ auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;
+ std::vector<details::log_msg_buffer> ret;
+ ret.reserve(n_items);
+ for (size_t i = (items_available - n_items); i < items_available; i++) {
+ ret.push_back(q_.at(i));
+ }
+ return ret;
+ }
+
+ std::vector<std::string> last_formatted(size_t lim = 0) {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ auto items_available = q_.size();
+ auto n_items = lim > 0 ? (std::min)(lim, items_available) : items_available;
+ std::vector<std::string> ret;
+ ret.reserve(n_items);
+ for (size_t i = (items_available - n_items); i < items_available; i++) {
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(q_.at(i), formatted);
+ ret.push_back(SPDLOG_BUF_TO_STRING(formatted));
+ }
+ return ret;
+ }
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ q_.push_back(details::log_msg_buffer{msg});
+ }
+ void flush_() override {}
+
+private:
+ details::circular_q<details::log_msg_buffer> q_;
+};
+
+using ringbuffer_sink_mt = ringbuffer_sink<std::mutex>;
+using ringbuffer_sink_st = ringbuffer_sink<details::null_mutex>;
+
+} // namespace sinks
+
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/rotating_file_sink-inl.h b/deps/include/spdlog/sinks/rotating_file_sink-inl.h new file mode 100644 index 0000000..6119be6 --- /dev/null +++ b/deps/include/spdlog/sinks/rotating_file_sink-inl.h @@ -0,0 +1,144 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+ #include <spdlog/sinks/rotating_file_sink.h>
+#endif
+
+#include <spdlog/common.h>
+
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/fmt/fmt.h>
+
+#include <cerrno>
+#include <chrono>
+#include <ctime>
+#include <mutex>
+#include <string>
+#include <tuple>
+
+namespace spdlog {
+namespace sinks {
+
+template <typename Mutex>
+SPDLOG_INLINE rotating_file_sink<Mutex>::rotating_file_sink(
+ filename_t base_filename,
+ std::size_t max_size,
+ std::size_t max_files,
+ bool rotate_on_open,
+ const file_event_handlers &event_handlers)
+ : base_filename_(std::move(base_filename)),
+ max_size_(max_size),
+ max_files_(max_files),
+ file_helper_{event_handlers} {
+ if (max_size == 0) {
+ throw_spdlog_ex("rotating sink constructor: max_size arg cannot be zero");
+ }
+
+ if (max_files > 200000) {
+ throw_spdlog_ex("rotating sink constructor: max_files arg cannot exceed 200000");
+ }
+ file_helper_.open(calc_filename(base_filename_, 0));
+ current_size_ = file_helper_.size(); // expensive. called only once
+ if (rotate_on_open && current_size_ > 0) {
+ rotate_();
+ current_size_ = 0;
+ }
+}
+
+// calc filename according to index and file extension if exists.
+// e.g. calc_filename("logs/mylog.txt, 3) => "logs/mylog.3.txt".
+template <typename Mutex>
+SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::calc_filename(const filename_t &filename,
+ std::size_t index) {
+ if (index == 0u) {
+ return filename;
+ }
+
+ filename_t basename, ext;
+ std::tie(basename, ext) = details::file_helper::split_by_extension(filename);
+ return fmt_lib::format(SPDLOG_FMT_STRING(SPDLOG_FILENAME_T("{}.{}{}")), basename, index, ext);
+}
+
+template <typename Mutex>
+SPDLOG_INLINE filename_t rotating_file_sink<Mutex>::filename() {
+ std::lock_guard<Mutex> lock(base_sink<Mutex>::mutex_);
+ return file_helper_.filename();
+}
+
+template <typename Mutex>
+SPDLOG_INLINE void rotating_file_sink<Mutex>::sink_it_(const details::log_msg &msg) {
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ auto new_size = current_size_ + formatted.size();
+
+ // rotate if the new estimated file size exceeds max size.
+ // rotate only if the real size > 0 to better deal with full disk (see issue #2261).
+ // we only check the real size when new_size > max_size_ because it is relatively expensive.
+ if (new_size > max_size_) {
+ file_helper_.flush();
+ if (file_helper_.size() > 0) {
+ rotate_();
+ new_size = formatted.size();
+ }
+ }
+ file_helper_.write(formatted);
+ current_size_ = new_size;
+}
+
+template <typename Mutex>
+SPDLOG_INLINE void rotating_file_sink<Mutex>::flush_() {
+ file_helper_.flush();
+}
+
+// Rotate files:
+// log.txt -> log.1.txt
+// log.1.txt -> log.2.txt
+// log.2.txt -> log.3.txt
+// log.3.txt -> delete
+template <typename Mutex>
+SPDLOG_INLINE void rotating_file_sink<Mutex>::rotate_() {
+ using details::os::filename_to_str;
+ using details::os::path_exists;
+
+ file_helper_.close();
+ for (auto i = max_files_; i > 0; --i) {
+ filename_t src = calc_filename(base_filename_, i - 1);
+ if (!path_exists(src)) {
+ continue;
+ }
+ filename_t target = calc_filename(base_filename_, i);
+
+ if (!rename_file_(src, target)) {
+ // if failed try again after a small delay.
+ // this is a workaround to a windows issue, where very high rotation
+ // rates can cause the rename to fail with permission denied (because of antivirus?).
+ details::os::sleep_for_millis(100);
+ if (!rename_file_(src, target)) {
+ file_helper_.reopen(
+ true); // truncate the log file anyway to prevent it to grow beyond its limit!
+ current_size_ = 0;
+ throw_spdlog_ex("rotating_file_sink: failed renaming " + filename_to_str(src) +
+ " to " + filename_to_str(target),
+ errno);
+ }
+ }
+ }
+ file_helper_.reopen(true);
+}
+
+// delete the target if exists, and rename the src file to target
+// return true on success, false otherwise.
+template <typename Mutex>
+SPDLOG_INLINE bool rotating_file_sink<Mutex>::rename_file_(const filename_t &src_filename,
+ const filename_t &target_filename) {
+ // try to delete the target file in case it already exists.
+ (void)details::os::remove(target_filename);
+ return details::os::rename(src_filename, target_filename) == 0;
+}
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/rotating_file_sink.h b/deps/include/spdlog/sinks/rotating_file_sink.h new file mode 100644 index 0000000..29ac745 --- /dev/null +++ b/deps/include/spdlog/sinks/rotating_file_sink.h @@ -0,0 +1,89 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/file_helper.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <chrono>
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+
+//
+// Rotating file sink based on size
+//
+template <typename Mutex>
+class rotating_file_sink final : public base_sink<Mutex> {
+public:
+ rotating_file_sink(filename_t base_filename,
+ std::size_t max_size,
+ std::size_t max_files,
+ bool rotate_on_open = false,
+ const file_event_handlers &event_handlers = {});
+ static filename_t calc_filename(const filename_t &filename, std::size_t index);
+ filename_t filename();
+
+protected:
+ void sink_it_(const details::log_msg &msg) override;
+ void flush_() override;
+
+private:
+ // Rotate files:
+ // log.txt -> log.1.txt
+ // log.1.txt -> log.2.txt
+ // log.2.txt -> log.3.txt
+ // log.3.txt -> delete
+ void rotate_();
+
+ // delete the target if exists, and rename the src file to target
+ // return true on success, false otherwise.
+ bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);
+
+ filename_t base_filename_;
+ std::size_t max_size_;
+ std::size_t max_files_;
+ std::size_t current_size_;
+ details::file_helper file_helper_;
+};
+
+using rotating_file_sink_mt = rotating_file_sink<std::mutex>;
+using rotating_file_sink_st = rotating_file_sink<details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+
+template <typename Factory = spdlog::synchronous_factory>
+inline 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 rotate_on_open = false,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::rotating_file_sink_mt>(
+ logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline 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 rotate_on_open = false,
+ const file_event_handlers &event_handlers = {}) {
+ return Factory::template create<sinks::rotating_file_sink_st>(
+ logger_name, filename, max_file_size, max_files, rotate_on_open, event_handlers);
+}
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+ #include "rotating_file_sink-inl.h"
+#endif
diff --git a/deps/include/spdlog/sinks/sink-inl.h b/deps/include/spdlog/sinks/sink-inl.h new file mode 100644 index 0000000..59beed5 --- /dev/null +++ b/deps/include/spdlog/sinks/sink-inl.h @@ -0,0 +1,22 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+ #include <spdlog/sinks/sink.h>
+#endif
+
+#include <spdlog/common.h>
+
+SPDLOG_INLINE bool spdlog::sinks::sink::should_log(spdlog::level::level_enum msg_level) const {
+ return msg_level >= level_.load(std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE void spdlog::sinks::sink::set_level(level::level_enum log_level) {
+ level_.store(log_level, std::memory_order_relaxed);
+}
+
+SPDLOG_INLINE spdlog::level::level_enum spdlog::sinks::sink::level() const {
+ return static_cast<spdlog::level::level_enum>(level_.load(std::memory_order_relaxed));
+}
diff --git a/deps/include/spdlog/sinks/sink.h b/deps/include/spdlog/sinks/sink.h new file mode 100644 index 0000000..0d0da3a --- /dev/null +++ b/deps/include/spdlog/sinks/sink.h @@ -0,0 +1,34 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/log_msg.h>
+#include <spdlog/formatter.h>
+
+namespace spdlog {
+
+namespace sinks {
+class SPDLOG_API sink {
+public:
+ virtual ~sink() = default;
+ virtual void log(const details::log_msg &msg) = 0;
+ virtual void flush() = 0;
+ virtual void set_pattern(const std::string &pattern) = 0;
+ virtual void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) = 0;
+
+ void set_level(level::level_enum log_level);
+ level::level_enum level() const;
+ bool should_log(level::level_enum msg_level) const;
+
+protected:
+ // sink log level - default is all
+ level_t level_{level::trace};
+};
+
+} // namespace sinks
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+ #include "sink-inl.h"
+#endif
diff --git a/deps/include/spdlog/sinks/stdout_color_sinks-inl.h b/deps/include/spdlog/sinks/stdout_color_sinks-inl.h new file mode 100644 index 0000000..ec05549 --- /dev/null +++ b/deps/include/spdlog/sinks/stdout_color_sinks-inl.h @@ -0,0 +1,38 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+ #include <spdlog/sinks/stdout_color_sinks.h>
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/logger.h>
+
+namespace spdlog {
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name,
+ color_mode mode) {
+ return Factory::template create<sinks::stdout_color_sink_mt>(logger_name, mode);
+}
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_color_st(const std::string &logger_name,
+ color_mode mode) {
+ return Factory::template create<sinks::stdout_color_sink_st>(logger_name, mode);
+}
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name,
+ color_mode mode) {
+ return Factory::template create<sinks::stderr_color_sink_mt>(logger_name, mode);
+}
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_color_st(const std::string &logger_name,
+ color_mode mode) {
+ return Factory::template create<sinks::stderr_color_sink_st>(logger_name, mode);
+}
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/stdout_color_sinks.h b/deps/include/spdlog/sinks/stdout_color_sinks.h new file mode 100644 index 0000000..933bcbf --- /dev/null +++ b/deps/include/spdlog/sinks/stdout_color_sinks.h @@ -0,0 +1,49 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifdef _WIN32
+ #include <spdlog/sinks/wincolor_sink.h>
+#else
+ #include <spdlog/sinks/ansicolor_sink.h>
+#endif
+
+#include <spdlog/details/synchronous_factory.h>
+
+namespace spdlog {
+namespace sinks {
+#ifdef _WIN32
+using stdout_color_sink_mt = wincolor_stdout_sink_mt;
+using stdout_color_sink_st = wincolor_stdout_sink_st;
+using stderr_color_sink_mt = wincolor_stderr_sink_mt;
+using stderr_color_sink_st = wincolor_stderr_sink_st;
+#else
+using stdout_color_sink_mt = ansicolor_stdout_sink_mt;
+using stdout_color_sink_st = ansicolor_stdout_sink_st;
+using stderr_color_sink_mt = ansicolor_stderr_sink_mt;
+using stderr_color_sink_st = ansicolor_stderr_sink_st;
+#endif
+} // namespace sinks
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_color_mt(const std::string &logger_name,
+ color_mode mode = color_mode::automatic);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_color_st(const std::string &logger_name,
+ color_mode mode = color_mode::automatic);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_color_mt(const std::string &logger_name,
+ color_mode mode = color_mode::automatic);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_color_st(const std::string &logger_name,
+ color_mode mode = color_mode::automatic);
+
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+ #include "stdout_color_sinks-inl.h"
+#endif
diff --git a/deps/include/spdlog/sinks/stdout_sinks-inl.h b/deps/include/spdlog/sinks/stdout_sinks-inl.h new file mode 100644 index 0000000..48a7330 --- /dev/null +++ b/deps/include/spdlog/sinks/stdout_sinks-inl.h @@ -0,0 +1,126 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+ #include <spdlog/sinks/stdout_sinks.h>
+#endif
+
+#include <memory>
+#include <spdlog/details/console_globals.h>
+#include <spdlog/pattern_formatter.h>
+
+#ifdef _WIN32
+ // under windows using fwrite to non-binary stream results in \r\r\n (see issue #1675)
+ // so instead we use ::FileWrite
+ #include <spdlog/details/windows_include.h>
+
+ #ifndef _USING_V110_SDK71_ // fileapi.h doesn't exist in winxp
+ #include <fileapi.h> // WriteFile (..)
+ #endif
+
+ #include <io.h> // _get_osfhandle(..)
+ #include <stdio.h> // _fileno(..)
+#endif // WIN32
+
+namespace spdlog {
+
+namespace sinks {
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE stdout_sink_base<ConsoleMutex>::stdout_sink_base(FILE *file)
+ : mutex_(ConsoleMutex::mutex()),
+ file_(file),
+ formatter_(details::make_unique<spdlog::pattern_formatter>()) {
+#ifdef _WIN32
+ // get windows handle from the FILE* object
+
+ handle_ = reinterpret_cast<HANDLE>(::_get_osfhandle(::_fileno(file_)));
+
+ // don't throw to support cases where no console is attached,
+ // and let the log method to do nothing if (handle_ == INVALID_HANDLE_VALUE).
+ // throw only if non stdout/stderr target is requested (probably regular file and not console).
+ if (handle_ == INVALID_HANDLE_VALUE && file != stdout && file != stderr) {
+ throw_spdlog_ex("spdlog::stdout_sink_base: _get_osfhandle() failed", errno);
+ }
+#endif // WIN32
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::log(const details::log_msg &msg) {
+#ifdef _WIN32
+ if (handle_ == INVALID_HANDLE_VALUE) {
+ return;
+ }
+ std::lock_guard<mutex_t> lock(mutex_);
+ memory_buf_t formatted;
+ formatter_->format(msg, formatted);
+ auto size = static_cast<DWORD>(formatted.size());
+ DWORD bytes_written = 0;
+ bool ok = ::WriteFile(handle_, formatted.data(), size, &bytes_written, nullptr) != 0;
+ if (!ok) {
+ throw_spdlog_ex("stdout_sink_base: WriteFile() failed. GetLastError(): " +
+ std::to_string(::GetLastError()));
+ }
+#else
+ std::lock_guard<mutex_t> lock(mutex_);
+ memory_buf_t formatted;
+ formatter_->format(msg, formatted);
+ ::fwrite(formatted.data(), sizeof(char), formatted.size(), file_);
+#endif // WIN32
+ ::fflush(file_); // flush every line to terminal
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::flush() {
+ std::lock_guard<mutex_t> lock(mutex_);
+ fflush(file_);
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_pattern(const std::string &pattern) {
+ std::lock_guard<mutex_t> lock(mutex_);
+ formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE void stdout_sink_base<ConsoleMutex>::set_formatter(
+ std::unique_ptr<spdlog::formatter> sink_formatter) {
+ std::lock_guard<mutex_t> lock(mutex_);
+ formatter_ = std::move(sink_formatter);
+}
+
+// stdout sink
+template <typename ConsoleMutex>
+SPDLOG_INLINE stdout_sink<ConsoleMutex>::stdout_sink()
+ : stdout_sink_base<ConsoleMutex>(stdout) {}
+
+// stderr sink
+template <typename ConsoleMutex>
+SPDLOG_INLINE stderr_sink<ConsoleMutex>::stderr_sink()
+ : stdout_sink_base<ConsoleMutex>(stderr) {}
+
+} // namespace sinks
+
+// factory methods
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name) {
+ return Factory::template create<sinks::stdout_sink_mt>(logger_name);
+}
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name) {
+ return Factory::template create<sinks::stdout_sink_st>(logger_name);
+}
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name) {
+ return Factory::template create<sinks::stderr_sink_mt>(logger_name);
+}
+
+template <typename Factory>
+SPDLOG_INLINE std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name) {
+ return Factory::template create<sinks::stderr_sink_st>(logger_name);
+}
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/stdout_sinks.h b/deps/include/spdlog/sinks/stdout_sinks.h new file mode 100644 index 0000000..20d116f --- /dev/null +++ b/deps/include/spdlog/sinks/stdout_sinks.h @@ -0,0 +1,84 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <cstdio>
+#include <spdlog/details/console_globals.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/sink.h>
+
+#ifdef _WIN32
+ #include <spdlog/details/windows_include.h>
+#endif
+
+namespace spdlog {
+
+namespace sinks {
+
+template <typename ConsoleMutex>
+class stdout_sink_base : public sink {
+public:
+ using mutex_t = typename ConsoleMutex::mutex_t;
+ explicit stdout_sink_base(FILE *file);
+ ~stdout_sink_base() override = default;
+
+ stdout_sink_base(const stdout_sink_base &other) = delete;
+ stdout_sink_base(stdout_sink_base &&other) = delete;
+
+ stdout_sink_base &operator=(const stdout_sink_base &other) = delete;
+ stdout_sink_base &operator=(stdout_sink_base &&other) = delete;
+
+ void log(const details::log_msg &msg) override;
+ void flush() override;
+ void set_pattern(const std::string &pattern) override;
+
+ void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override;
+
+protected:
+ mutex_t &mutex_;
+ FILE *file_;
+ std::unique_ptr<spdlog::formatter> formatter_;
+#ifdef _WIN32
+ HANDLE handle_;
+#endif // WIN32
+};
+
+template <typename ConsoleMutex>
+class stdout_sink : public stdout_sink_base<ConsoleMutex> {
+public:
+ stdout_sink();
+};
+
+template <typename ConsoleMutex>
+class stderr_sink : public stdout_sink_base<ConsoleMutex> {
+public:
+ stderr_sink();
+};
+
+using stdout_sink_mt = stdout_sink<details::console_mutex>;
+using stdout_sink_st = stdout_sink<details::console_nullmutex>;
+
+using stderr_sink_mt = stderr_sink<details::console_mutex>;
+using stderr_sink_st = stderr_sink<details::console_nullmutex>;
+
+} // namespace sinks
+
+// factory methods
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_logger_mt(const std::string &logger_name);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stdout_logger_st(const std::string &logger_name);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_logger_mt(const std::string &logger_name);
+
+template <typename Factory = spdlog::synchronous_factory>
+std::shared_ptr<logger> stderr_logger_st(const std::string &logger_name);
+
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+ #include "stdout_sinks-inl.h"
+#endif
diff --git a/deps/include/spdlog/sinks/syslog_sink.h b/deps/include/spdlog/sinks/syslog_sink.h new file mode 100644 index 0000000..7f80657 --- /dev/null +++ b/deps/include/spdlog/sinks/syslog_sink.h @@ -0,0 +1,104 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <array>
+#include <string>
+#include <syslog.h>
+
+namespace spdlog {
+namespace sinks {
+/**
+ * Sink that write to syslog using the `syscall()` library call.
+ */
+template <typename Mutex>
+class syslog_sink : public base_sink<Mutex> {
+public:
+ syslog_sink(std::string ident, int syslog_option, int syslog_facility, bool enable_formatting)
+ : enable_formatting_{enable_formatting},
+ syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG,
+ /* spdlog::level::debug */ LOG_DEBUG,
+ /* spdlog::level::info */ LOG_INFO,
+ /* spdlog::level::warn */ LOG_WARNING,
+ /* spdlog::level::err */ LOG_ERR,
+ /* spdlog::level::critical */ LOG_CRIT,
+ /* spdlog::level::off */ LOG_INFO}},
+ ident_{std::move(ident)} {
+ // set ident to be program name if empty
+ ::openlog(ident_.empty() ? nullptr : ident_.c_str(), syslog_option, syslog_facility);
+ }
+
+ ~syslog_sink() override { ::closelog(); }
+
+ syslog_sink(const syslog_sink &) = delete;
+ syslog_sink &operator=(const syslog_sink &) = delete;
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ string_view_t payload;
+ memory_buf_t formatted;
+ if (enable_formatting_) {
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ payload = string_view_t(formatted.data(), formatted.size());
+ } else {
+ payload = msg.payload;
+ }
+
+ size_t length = payload.size();
+ // limit to max int
+ if (length > static_cast<size_t>(std::numeric_limits<int>::max())) {
+ length = static_cast<size_t>(std::numeric_limits<int>::max());
+ }
+
+ ::syslog(syslog_prio_from_level(msg), "%.*s", static_cast<int>(length), payload.data());
+ }
+
+ void flush_() override {}
+ bool enable_formatting_ = false;
+
+ //
+ // Simply maps spdlog's log level to syslog priority level.
+ //
+ virtual int syslog_prio_from_level(const details::log_msg &msg) const {
+ return syslog_levels_.at(static_cast<levels_array::size_type>(msg.level));
+ }
+
+ using levels_array = std::array<int, 7>;
+ levels_array syslog_levels_;
+
+private:
+ // must store the ident because the man says openlog might use the pointer as
+ // is and not a string copy
+ const std::string ident_;
+};
+
+using syslog_sink_mt = syslog_sink<std::mutex>;
+using syslog_sink_st = syslog_sink<details::null_mutex>;
+} // namespace sinks
+
+// Create and register a syslog logger
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> syslog_logger_mt(const std::string &logger_name,
+ const std::string &syslog_ident = "",
+ int syslog_option = 0,
+ int syslog_facility = LOG_USER,
+ bool enable_formatting = false) {
+ return Factory::template create<sinks::syslog_sink_mt>(logger_name, syslog_ident, syslog_option,
+ syslog_facility, enable_formatting);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> syslog_logger_st(const std::string &logger_name,
+ const std::string &syslog_ident = "",
+ int syslog_option = 0,
+ int syslog_facility = LOG_USER,
+ bool enable_formatting = false) {
+ return Factory::template create<sinks::syslog_sink_st>(logger_name, syslog_ident, syslog_option,
+ syslog_facility, enable_formatting);
+}
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/systemd_sink.h b/deps/include/spdlog/sinks/systemd_sink.h new file mode 100644 index 0000000..dee0fe6 --- /dev/null +++ b/deps/include/spdlog/sinks/systemd_sink.h @@ -0,0 +1,121 @@ +// Copyright(c) 2019 ZVYAGIN.Alexander@gmail.com
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/synchronous_factory.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <array>
+#ifndef SD_JOURNAL_SUPPRESS_LOCATION
+ #define SD_JOURNAL_SUPPRESS_LOCATION
+#endif
+#include <systemd/sd-journal.h>
+
+namespace spdlog {
+namespace sinks {
+
+/**
+ * Sink that write to systemd journal using the `sd_journal_send()` library call.
+ */
+template <typename Mutex>
+class systemd_sink : public base_sink<Mutex> {
+public:
+ systemd_sink(std::string ident = "", bool enable_formatting = false)
+ : ident_{std::move(ident)},
+ enable_formatting_{enable_formatting},
+ syslog_levels_{{/* spdlog::level::trace */ LOG_DEBUG,
+ /* spdlog::level::debug */ LOG_DEBUG,
+ /* spdlog::level::info */ LOG_INFO,
+ /* spdlog::level::warn */ LOG_WARNING,
+ /* spdlog::level::err */ LOG_ERR,
+ /* spdlog::level::critical */ LOG_CRIT,
+ /* spdlog::level::off */ LOG_INFO}} {}
+
+ ~systemd_sink() override {}
+
+ systemd_sink(const systemd_sink &) = delete;
+ systemd_sink &operator=(const systemd_sink &) = delete;
+
+protected:
+ const std::string ident_;
+ bool enable_formatting_ = false;
+ using levels_array = std::array<int, 7>;
+ levels_array syslog_levels_;
+
+ void sink_it_(const details::log_msg &msg) override {
+ int err;
+ string_view_t payload;
+ memory_buf_t formatted;
+ if (enable_formatting_) {
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ payload = string_view_t(formatted.data(), formatted.size());
+ } else {
+ payload = msg.payload;
+ }
+
+ size_t length = payload.size();
+ // limit to max int
+ if (length > static_cast<size_t>(std::numeric_limits<int>::max())) {
+ length = static_cast<size_t>(std::numeric_limits<int>::max());
+ }
+
+ const string_view_t syslog_identifier = ident_.empty() ? msg.logger_name : ident_;
+
+ // Do not send source location if not available
+ if (msg.source.empty()) {
+ // Note: function call inside '()' to avoid macro expansion
+ err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(),
+ "PRIORITY=%d", syslog_level(msg.level),
+#ifndef SPDLOG_NO_THREAD_ID
+ "TID=%zu", msg.thread_id,
+#endif
+ "SYSLOG_IDENTIFIER=%.*s",
+ static_cast<int>(syslog_identifier.size()),
+ syslog_identifier.data(), nullptr);
+ } else {
+ err = (sd_journal_send)("MESSAGE=%.*s", static_cast<int>(length), payload.data(),
+ "PRIORITY=%d", syslog_level(msg.level),
+#ifndef SPDLOG_NO_THREAD_ID
+ "TID=%zu", msg.thread_id,
+#endif
+ "SYSLOG_IDENTIFIER=%.*s",
+ static_cast<int>(syslog_identifier.size()),
+ syslog_identifier.data(), "CODE_FILE=%s", msg.source.filename,
+ "CODE_LINE=%d", msg.source.line, "CODE_FUNC=%s",
+ msg.source.funcname, nullptr);
+ }
+
+ if (err) {
+ throw_spdlog_ex("Failed writing to systemd", errno);
+ }
+ }
+
+ int syslog_level(level::level_enum l) {
+ return syslog_levels_.at(static_cast<levels_array::size_type>(l));
+ }
+
+ void flush_() override {}
+};
+
+using systemd_sink_mt = systemd_sink<std::mutex>;
+using systemd_sink_st = systemd_sink<details::null_mutex>;
+} // namespace sinks
+
+// Create and register a syslog logger
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> systemd_logger_mt(const std::string &logger_name,
+ const std::string &ident = "",
+ bool enable_formatting = false) {
+ return Factory::template create<sinks::systemd_sink_mt>(logger_name, ident, enable_formatting);
+}
+
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> systemd_logger_st(const std::string &logger_name,
+ const std::string &ident = "",
+ bool enable_formatting = false) {
+ return Factory::template create<sinks::systemd_sink_st>(logger_name, ident, enable_formatting);
+}
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/tcp_sink.h b/deps/include/spdlog/sinks/tcp_sink.h new file mode 100644 index 0000000..810a049 --- /dev/null +++ b/deps/include/spdlog/sinks/tcp_sink.h @@ -0,0 +1,75 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#ifdef _WIN32
+ #include <spdlog/details/tcp_client-windows.h>
+#else
+ #include <spdlog/details/tcp_client.h>
+#endif
+
+#include <chrono>
+#include <functional>
+#include <mutex>
+#include <string>
+
+#pragma once
+
+// Simple tcp client sink
+// Connects to remote address and send the formatted log.
+// Will attempt to reconnect if connection drops.
+// If more complicated behaviour is needed (i.e get responses), you can inherit it and override the
+// sink_it_ method.
+
+namespace spdlog {
+namespace sinks {
+
+struct tcp_sink_config {
+ std::string server_host;
+ int server_port;
+ bool lazy_connect = false; // if true connect on first log call instead of on construction
+
+ tcp_sink_config(std::string host, int port)
+ : server_host{std::move(host)},
+ server_port{port} {}
+};
+
+template <typename Mutex>
+class tcp_sink : public spdlog::sinks::base_sink<Mutex> {
+public:
+ // connect to tcp host/port or throw if failed
+ // host can be hostname or ip address
+
+ explicit tcp_sink(tcp_sink_config sink_config)
+ : config_{std::move(sink_config)} {
+ if (!config_.lazy_connect) {
+ this->client_.connect(config_.server_host, config_.server_port);
+ }
+ }
+
+ ~tcp_sink() override = default;
+
+protected:
+ void sink_it_(const spdlog::details::log_msg &msg) override {
+ spdlog::memory_buf_t formatted;
+ spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted);
+ if (!client_.is_connected()) {
+ client_.connect(config_.server_host, config_.server_port);
+ }
+ client_.send(formatted.data(), formatted.size());
+ }
+
+ void flush_() override {}
+ tcp_sink_config config_;
+ details::tcp_client client_;
+};
+
+using tcp_sink_mt = tcp_sink<std::mutex>;
+using tcp_sink_st = tcp_sink<spdlog::details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/udp_sink.h b/deps/include/spdlog/sinks/udp_sink.h new file mode 100644 index 0000000..a135e62 --- /dev/null +++ b/deps/include/spdlog/sinks/udp_sink.h @@ -0,0 +1,69 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+#ifdef _WIN32
+ #include <spdlog/details/udp_client-windows.h>
+#else
+ #include <spdlog/details/udp_client.h>
+#endif
+
+#include <chrono>
+#include <functional>
+#include <mutex>
+#include <string>
+
+// Simple udp client sink
+// Sends formatted log via udp
+
+namespace spdlog {
+namespace sinks {
+
+struct udp_sink_config {
+ std::string server_host;
+ uint16_t server_port;
+
+ udp_sink_config(std::string host, uint16_t port)
+ : server_host{std::move(host)},
+ server_port{port} {}
+};
+
+template <typename Mutex>
+class udp_sink : public spdlog::sinks::base_sink<Mutex> {
+public:
+ // host can be hostname or ip address
+ explicit udp_sink(udp_sink_config sink_config)
+ : client_{sink_config.server_host, sink_config.server_port} {}
+
+ ~udp_sink() override = default;
+
+protected:
+ void sink_it_(const spdlog::details::log_msg &msg) override {
+ spdlog::memory_buf_t formatted;
+ spdlog::sinks::base_sink<Mutex>::formatter_->format(msg, formatted);
+ client_.send(formatted.data(), formatted.size());
+ }
+
+ void flush_() override {}
+ details::udp_client client_;
+};
+
+using udp_sink_mt = udp_sink<std::mutex>;
+using udp_sink_st = udp_sink<spdlog::details::null_mutex>;
+
+} // namespace sinks
+
+//
+// factory functions
+//
+template <typename Factory = spdlog::synchronous_factory>
+inline std::shared_ptr<logger> udp_logger_mt(const std::string &logger_name,
+ sinks::udp_sink_config skin_config) {
+ return Factory::template create<sinks::udp_sink_mt>(logger_name, skin_config);
+}
+
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/win_eventlog_sink.h b/deps/include/spdlog/sinks/win_eventlog_sink.h new file mode 100644 index 0000000..b1d81c6 --- /dev/null +++ b/deps/include/spdlog/sinks/win_eventlog_sink.h @@ -0,0 +1,260 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+// Writing to Windows Event Log requires the registry entries below to be present, with the
+// following modifications:
+// 1. <log_name> should be replaced with your log name (e.g. your application name)
+// 2. <source_name> should be replaced with the specific source name and the key should be
+// duplicated for
+// each source used in the application
+//
+// Since typically modifications of this kind require elevation, it's better to do it as a part of
+// setup procedure. The snippet below uses mscoree.dll as the message file as it exists on most of
+// the Windows systems anyway and happens to contain the needed resource.
+//
+// You can also specify a custom message file if needed.
+// Please refer to Event Log functions descriptions in MSDN for more details on custom message
+// files.
+
+/*---------------------------------------------------------------------------------------
+
+Windows Registry Editor Version 5.00
+
+[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\<log_name>]
+
+[HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\EventLog\<log_name>\<source_name>]
+"TypesSupported"=dword:00000007
+"EventMessageFile"=hex(2):25,00,73,00,79,00,73,00,74,00,65,00,6d,00,72,00,6f,\
+ 00,6f,00,74,00,25,00,5c,00,53,00,79,00,73,00,74,00,65,00,6d,00,33,00,32,00,\
+ 5c,00,6d,00,73,00,63,00,6f,00,72,00,65,00,65,00,2e,00,64,00,6c,00,6c,00,00,\
+ 00
+
+-----------------------------------------------------------------------------------------*/
+
+#pragma once
+
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/base_sink.h>
+
+#include <spdlog/details/windows_include.h>
+#include <winbase.h>
+
+#include <mutex>
+#include <string>
+#include <vector>
+
+namespace spdlog {
+namespace sinks {
+
+namespace win_eventlog {
+
+namespace internal {
+
+struct local_alloc_t {
+ HLOCAL hlocal_;
+
+ SPDLOG_CONSTEXPR local_alloc_t() SPDLOG_NOEXCEPT : hlocal_(nullptr) {}
+
+ local_alloc_t(local_alloc_t const &) = delete;
+ local_alloc_t &operator=(local_alloc_t const &) = delete;
+
+ ~local_alloc_t() SPDLOG_NOEXCEPT {
+ if (hlocal_) {
+ LocalFree(hlocal_);
+ }
+ }
+};
+
+/** Windows error */
+struct win32_error : public spdlog_ex {
+ /** Formats an error report line: "user-message: error-code (system message)" */
+ static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) {
+ std::string system_message;
+
+ local_alloc_t format_message_result{};
+ auto format_message_succeeded =
+ ::FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ (LPSTR)&format_message_result.hlocal_, 0, nullptr);
+
+ if (format_message_succeeded && format_message_result.hlocal_) {
+ system_message = fmt_lib::format(" ({})", (LPSTR)format_message_result.hlocal_);
+ }
+
+ return fmt_lib::format("{}: {}{}", user_message, error_code, system_message);
+ }
+
+ explicit win32_error(std::string const &func_name, DWORD error = GetLastError())
+ : spdlog_ex(format(func_name, error)) {}
+};
+
+/** Wrapper for security identifiers (SID) on Windows */
+struct sid_t {
+ std::vector<char> buffer_;
+
+public:
+ sid_t() {}
+
+ /** creates a wrapped SID copy */
+ static sid_t duplicate_sid(PSID psid) {
+ if (!::IsValidSid(psid)) {
+ throw_spdlog_ex("sid_t::sid_t(): invalid SID received");
+ }
+
+ auto const sid_length{::GetLengthSid(psid)};
+
+ sid_t result;
+ result.buffer_.resize(sid_length);
+ if (!::CopySid(sid_length, (PSID)result.as_sid(), psid)) {
+ SPDLOG_THROW(win32_error("CopySid"));
+ }
+
+ return result;
+ }
+
+ /** Retrieves pointer to the internal buffer contents as SID* */
+ SID *as_sid() const { return buffer_.empty() ? nullptr : (SID *)buffer_.data(); }
+
+ /** Get SID for the current user */
+ static sid_t get_current_user_sid() {
+ /* create and init RAII holder for process token */
+ struct process_token_t {
+ HANDLE token_handle_ = INVALID_HANDLE_VALUE;
+ explicit process_token_t(HANDLE process) {
+ if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) {
+ SPDLOG_THROW(win32_error("OpenProcessToken"));
+ }
+ }
+
+ ~process_token_t() { ::CloseHandle(token_handle_); }
+
+ } current_process_token(
+ ::GetCurrentProcess()); // GetCurrentProcess returns pseudohandle, no leak here!
+
+ // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return
+ // the token size
+ DWORD tusize = 0;
+ if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0,
+ &tusize)) {
+ SPDLOG_THROW(win32_error("GetTokenInformation should fail"));
+ }
+
+ // get user token
+ std::vector<unsigned char> buffer(static_cast<size_t>(tusize));
+ if (!::GetTokenInformation(current_process_token.token_handle_, TokenUser,
+ (LPVOID)buffer.data(), tusize, &tusize)) {
+ SPDLOG_THROW(win32_error("GetTokenInformation"));
+ }
+
+ // create a wrapper of the SID data as stored in the user token
+ return sid_t::duplicate_sid(((TOKEN_USER *)buffer.data())->User.Sid);
+ }
+};
+
+struct eventlog {
+ static WORD get_event_type(details::log_msg const &msg) {
+ switch (msg.level) {
+ case level::trace:
+ case level::debug:
+ return EVENTLOG_SUCCESS;
+
+ case level::info:
+ return EVENTLOG_INFORMATION_TYPE;
+
+ case level::warn:
+ return EVENTLOG_WARNING_TYPE;
+
+ case level::err:
+ case level::critical:
+ case level::off:
+ return EVENTLOG_ERROR_TYPE;
+
+ default:
+ return EVENTLOG_INFORMATION_TYPE;
+ }
+ }
+
+ static WORD get_event_category(details::log_msg const &msg) { return (WORD)msg.level; }
+};
+
+} // namespace internal
+
+/*
+ * Windows Event Log sink
+ */
+template <typename Mutex>
+class win_eventlog_sink : public base_sink<Mutex> {
+private:
+ HANDLE hEventLog_{NULL};
+ internal::sid_t current_user_sid_;
+ std::string source_;
+ DWORD event_id_;
+
+ HANDLE event_log_handle() {
+ if (!hEventLog_) {
+ hEventLog_ = ::RegisterEventSourceA(nullptr, source_.c_str());
+ if (!hEventLog_ || hEventLog_ == (HANDLE)ERROR_ACCESS_DENIED) {
+ SPDLOG_THROW(internal::win32_error("RegisterEventSource"));
+ }
+ }
+
+ return hEventLog_;
+ }
+
+protected:
+ void sink_it_(const details::log_msg &msg) override {
+ using namespace internal;
+
+ bool succeeded;
+ memory_buf_t formatted;
+ base_sink<Mutex>::formatter_->format(msg, formatted);
+ formatted.push_back('\0');
+
+#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
+ wmemory_buf_t buf;
+ details::os::utf8_to_wstrbuf(string_view_t(formatted.data(), formatted.size()), buf);
+
+ LPCWSTR lp_wstr = buf.data();
+ succeeded = static_cast<bool>(::ReportEventW(
+ event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),
+ event_id_, current_user_sid_.as_sid(), 1, 0, &lp_wstr, nullptr));
+#else
+ LPCSTR lp_str = formatted.data();
+ succeeded = static_cast<bool>(::ReportEventA(
+ event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg),
+ event_id_, current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr));
+#endif
+
+ if (!succeeded) {
+ SPDLOG_THROW(win32_error("ReportEvent"));
+ }
+ }
+
+ void flush_() override {}
+
+public:
+ win_eventlog_sink(std::string const &source,
+ DWORD event_id = 1000 /* according to mscoree.dll */)
+ : source_(source),
+ event_id_(event_id) {
+ try {
+ current_user_sid_ = internal::sid_t::get_current_user_sid();
+ } catch (...) {
+ // get_current_user_sid() is unlikely to fail and if it does, we can still proceed
+ // without current_user_sid but in the event log the record will have no user name
+ }
+ }
+
+ ~win_eventlog_sink() {
+ if (hEventLog_) DeregisterEventSource(hEventLog_);
+ }
+};
+
+} // namespace win_eventlog
+
+using win_eventlog_sink_mt = win_eventlog::win_eventlog_sink<std::mutex>;
+using win_eventlog_sink_st = win_eventlog::win_eventlog_sink<details::null_mutex>;
+
+} // namespace sinks
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/wincolor_sink-inl.h b/deps/include/spdlog/sinks/wincolor_sink-inl.h new file mode 100644 index 0000000..e89dd7c --- /dev/null +++ b/deps/include/spdlog/sinks/wincolor_sink-inl.h @@ -0,0 +1,172 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#ifndef SPDLOG_HEADER_ONLY
+ #include <spdlog/sinks/wincolor_sink.h>
+#endif
+
+#include <spdlog/details/windows_include.h>
+#include <wincon.h>
+
+#include <spdlog/common.h>
+#include <spdlog/pattern_formatter.h>
+
+namespace spdlog {
+namespace sinks {
+template <typename ConsoleMutex>
+SPDLOG_INLINE wincolor_sink<ConsoleMutex>::wincolor_sink(void *out_handle, color_mode mode)
+ : out_handle_(out_handle),
+ mutex_(ConsoleMutex::mutex()),
+ formatter_(details::make_unique<spdlog::pattern_formatter>()) {
+ set_color_mode_impl(mode);
+ // set level colors
+ colors_[level::trace] = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; // white
+ colors_[level::debug] = FOREGROUND_GREEN | FOREGROUND_BLUE; // cyan
+ colors_[level::info] = FOREGROUND_GREEN; // green
+ colors_[level::warn] =
+ FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_INTENSITY; // intense yellow
+ colors_[level::err] = FOREGROUND_RED | FOREGROUND_INTENSITY; // intense red
+ colors_[level::critical] = BACKGROUND_RED | FOREGROUND_RED | FOREGROUND_GREEN |
+ FOREGROUND_BLUE |
+ FOREGROUND_INTENSITY; // intense white on red background
+ colors_[level::off] = 0;
+}
+
+template <typename ConsoleMutex>
+SPDLOG_INLINE wincolor_sink<ConsoleMutex>::~wincolor_sink() {
+ this->flush();
+}
+
+// change the color for the given level
+template <typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color(level::level_enum level,
+ std::uint16_t color) {
+ std::lock_guard<mutex_t> lock(mutex_);
+ colors_[static_cast<size_t>(level)] = color;
+}
+
+template <typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::log(const details::log_msg &msg) {
+ if (out_handle_ == nullptr || out_handle_ == INVALID_HANDLE_VALUE) {
+ return;
+ }
+
+ std::lock_guard<mutex_t> lock(mutex_);
+ msg.color_range_start = 0;
+ msg.color_range_end = 0;
+ memory_buf_t formatted;
+ formatter_->format(msg, formatted);
+ if (should_do_colors_ && msg.color_range_end > msg.color_range_start) {
+ // before color range
+ print_range_(formatted, 0, msg.color_range_start);
+ // in color range
+ auto orig_attribs =
+ static_cast<WORD>(set_foreground_color_(colors_[static_cast<size_t>(msg.level)]));
+ print_range_(formatted, msg.color_range_start, msg.color_range_end);
+ // reset to orig colors
+ ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), orig_attribs);
+ print_range_(formatted, msg.color_range_end, formatted.size());
+ } else // print without colors if color range is invalid (or color is disabled)
+ {
+ write_to_file_(formatted);
+ }
+}
+
+template <typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::flush() {
+ // windows console always flushed?
+}
+
+template <typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_pattern(const std::string &pattern) {
+ std::lock_guard<mutex_t> lock(mutex_);
+ formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
+}
+
+template <typename ConsoleMutex>
+void SPDLOG_INLINE
+wincolor_sink<ConsoleMutex>::set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) {
+ std::lock_guard<mutex_t> lock(mutex_);
+ formatter_ = std::move(sink_formatter);
+}
+
+template <typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode(color_mode mode) {
+ std::lock_guard<mutex_t> lock(mutex_);
+ set_color_mode_impl(mode);
+}
+
+template <typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::set_color_mode_impl(color_mode mode) {
+ if (mode == color_mode::automatic) {
+ // should do colors only if out_handle_ points to actual console.
+ DWORD console_mode;
+ bool in_console = ::GetConsoleMode(static_cast<HANDLE>(out_handle_), &console_mode) != 0;
+ should_do_colors_ = in_console;
+ } else {
+ should_do_colors_ = mode == color_mode::always ? true : false;
+ }
+}
+
+// set foreground color and return the orig console attributes (for resetting later)
+template <typename ConsoleMutex>
+std::uint16_t SPDLOG_INLINE
+wincolor_sink<ConsoleMutex>::set_foreground_color_(std::uint16_t attribs) {
+ CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info;
+ if (!::GetConsoleScreenBufferInfo(static_cast<HANDLE>(out_handle_), &orig_buffer_info)) {
+ // just return white if failed getting console info
+ return FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+ }
+
+ // change only the foreground bits (lowest 4 bits)
+ auto new_attribs = static_cast<WORD>(attribs) | (orig_buffer_info.wAttributes & 0xfff0);
+ auto ignored =
+ ::SetConsoleTextAttribute(static_cast<HANDLE>(out_handle_), static_cast<WORD>(new_attribs));
+ (void)(ignored);
+ return static_cast<std::uint16_t>(orig_buffer_info.wAttributes); // return orig attribs
+}
+
+// print a range of formatted message to console
+template <typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::print_range_(const memory_buf_t &formatted,
+ size_t start,
+ size_t end) {
+ if (end > start) {
+#if defined(SPDLOG_UTF8_TO_WCHAR_CONSOLE)
+ wmemory_buf_t wformatted;
+ details::os::utf8_to_wstrbuf(string_view_t(formatted.data() + start, end - start),
+ wformatted);
+ auto size = static_cast<DWORD>(wformatted.size());
+ auto ignored = ::WriteConsoleW(static_cast<HANDLE>(out_handle_), wformatted.data(), size,
+ nullptr, nullptr);
+#else
+ auto size = static_cast<DWORD>(end - start);
+ auto ignored = ::WriteConsoleA(static_cast<HANDLE>(out_handle_), formatted.data() + start,
+ size, nullptr, nullptr);
+#endif
+ (void)(ignored);
+ }
+}
+
+template <typename ConsoleMutex>
+void SPDLOG_INLINE wincolor_sink<ConsoleMutex>::write_to_file_(const memory_buf_t &formatted) {
+ auto size = static_cast<DWORD>(formatted.size());
+ DWORD bytes_written = 0;
+ auto ignored = ::WriteFile(static_cast<HANDLE>(out_handle_), formatted.data(), size,
+ &bytes_written, nullptr);
+ (void)(ignored);
+}
+
+// wincolor_stdout_sink
+template <typename ConsoleMutex>
+SPDLOG_INLINE wincolor_stdout_sink<ConsoleMutex>::wincolor_stdout_sink(color_mode mode)
+ : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_OUTPUT_HANDLE), mode) {}
+
+// wincolor_stderr_sink
+template <typename ConsoleMutex>
+SPDLOG_INLINE wincolor_stderr_sink<ConsoleMutex>::wincolor_stderr_sink(color_mode mode)
+ : wincolor_sink<ConsoleMutex>(::GetStdHandle(STD_ERROR_HANDLE), mode) {}
+} // namespace sinks
+} // namespace spdlog
diff --git a/deps/include/spdlog/sinks/wincolor_sink.h b/deps/include/spdlog/sinks/wincolor_sink.h new file mode 100644 index 0000000..3355e5f --- /dev/null +++ b/deps/include/spdlog/sinks/wincolor_sink.h @@ -0,0 +1,82 @@ +// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+#include <spdlog/common.h>
+#include <spdlog/details/console_globals.h>
+#include <spdlog/details/null_mutex.h>
+#include <spdlog/sinks/sink.h>
+
+#include <array>
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <string>
+
+namespace spdlog {
+namespace sinks {
+/*
+ * Windows color console sink. Uses WriteConsoleA to write to the console with
+ * colors
+ */
+template <typename ConsoleMutex>
+class wincolor_sink : public sink {
+public:
+ wincolor_sink(void *out_handle, color_mode mode);
+ ~wincolor_sink() override;
+
+ wincolor_sink(const wincolor_sink &other) = delete;
+ wincolor_sink &operator=(const wincolor_sink &other) = delete;
+
+ // change the color for the given level
+ void set_color(level::level_enum level, std::uint16_t color);
+ void log(const details::log_msg &msg) final override;
+ void flush() final override;
+ void set_pattern(const std::string &pattern) override final;
+ void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) override final;
+ void set_color_mode(color_mode mode);
+
+protected:
+ using mutex_t = typename ConsoleMutex::mutex_t;
+ void *out_handle_;
+ mutex_t &mutex_;
+ bool should_do_colors_;
+ std::unique_ptr<spdlog::formatter> formatter_;
+ std::array<std::uint16_t, level::n_levels> colors_;
+
+ // set foreground color and return the orig console attributes (for resetting later)
+ std::uint16_t set_foreground_color_(std::uint16_t attribs);
+
+ // print a range of formatted message to console
+ void print_range_(const memory_buf_t &formatted, size_t start, size_t end);
+
+ // in case we are redirected to file (not in console mode)
+ void write_to_file_(const memory_buf_t &formatted);
+
+ void set_color_mode_impl(color_mode mode);
+};
+
+template <typename ConsoleMutex>
+class wincolor_stdout_sink : public wincolor_sink<ConsoleMutex> {
+public:
+ explicit wincolor_stdout_sink(color_mode mode = color_mode::automatic);
+};
+
+template <typename ConsoleMutex>
+class wincolor_stderr_sink : public wincolor_sink<ConsoleMutex> {
+public:
+ explicit wincolor_stderr_sink(color_mode mode = color_mode::automatic);
+};
+
+using wincolor_stdout_sink_mt = wincolor_stdout_sink<details::console_mutex>;
+using wincolor_stdout_sink_st = wincolor_stdout_sink<details::console_nullmutex>;
+
+using wincolor_stderr_sink_mt = wincolor_stderr_sink<details::console_mutex>;
+using wincolor_stderr_sink_st = wincolor_stderr_sink<details::console_nullmutex>;
+} // namespace sinks
+} // namespace spdlog
+
+#ifdef SPDLOG_HEADER_ONLY
+ #include "wincolor_sink-inl.h"
+#endif
|