Upgraded spdlog to v1.11.0

thirdparty/spdlog/details/circular_q.h

@@ -121,6 +121,11 @@ public:
         return overrun_counter_;
     }
 
+    void reset_overrun_counter()
+    {
+        overrun_counter_ = 0;
+    }
+
 private:
     // copy from other&& and reset it to disabled state
     void copy_moveable(circular_q &&other) SPDLOG_NOEXCEPT

thirdparty/spdlog/details/file_helper-inl.h

@@ -20,6 +20,10 @@
 namespace spdlog {
 namespace details {
 
+SPDLOG_INLINE file_helper::file_helper(const file_event_handlers &event_handlers)
+    : event_handlers_(event_handlers)
+{}
+
 SPDLOG_INLINE file_helper::~file_helper()
 {
     close();
@@ -33,6 +37,10 @@ SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
     auto *mode = SPDLOG_FILENAME_T("ab");
     auto *trunc_mode = SPDLOG_FILENAME_T("wb");
 
+    if (event_handlers_.before_open)
+    {
+        event_handlers_.before_open(filename_);
+    }
     for (int tries = 0; tries < open_tries_; ++tries)
     {
         // create containing folder if not exists already.
@@ -52,6 +60,10 @@ SPDLOG_INLINE void file_helper::open(const filename_t &fname, bool truncate)
         }
         if (!os::fopen_s(&fd_, fname, mode))
         {
+            if (event_handlers_.after_open)
+            {
+                event_handlers_.after_open(filename_, fd_);
+            }
             return;
         }
 
@@ -72,15 +84,28 @@ SPDLOG_INLINE void file_helper::reopen(bool truncate)
 
 SPDLOG_INLINE void file_helper::flush()
 {
-    std::fflush(fd_);
+    if (std::fflush(fd_) != 0)
+    {
+        throw_spdlog_ex("Failed flush to file " + os::filename_to_str(filename_), errno);
+    }
 }
 
 SPDLOG_INLINE void file_helper::close()
 {
     if (fd_ != nullptr)
     {
+        if (event_handlers_.before_close)
+        {
+            event_handlers_.before_close(filename_, fd_);
+        }
+
         std::fclose(fd_);
         fd_ = nullptr;
+
+        if (event_handlers_.after_close)
+        {
+            event_handlers_.after_close(filename_);
+        }
     }
 }
 

thirdparty/spdlog/details/file_helper.h

@@ -16,7 +16,8 @@ namespace details {
 class SPDLOG_API file_helper
 {
 public:
-    explicit file_helper() = default;
+    file_helper() = default;
+    explicit file_helper(const file_event_handlers &event_handlers);
 
     file_helper(const file_helper &) = delete;
     file_helper &operator=(const file_helper &) = delete;
@@ -50,6 +51,7 @@ private:
     const unsigned int open_interval_ = 10;
     std::FILE *fd_{nullptr};
     filename_t filename_;
+    file_event_handlers event_handlers_;
 };
 } // namespace details
 } // namespace spdlog

thirdparty/spdlog/details/fmt_helper.h

@@ -8,6 +8,11 @@
 #include <spdlog/fmt/fmt.h>
 #include <spdlog/common.h>
 
+#ifdef SPDLOG_USE_STD_FORMAT
+#    include <charconv>
+#    include <limits>
+#endif
+
 // Some fmt helpers to efficiently format and pad ints and strings
 namespace spdlog {
 namespace details {
@@ -24,26 +29,73 @@ inline void append_string_view(spdlog::string_view_t view, memory_buf_t &dest)
     dest.append(buf_ptr, buf_ptr + view.size());
 }
 
+#ifdef SPDLOG_USE_STD_FORMAT
+template<typename T>
+inline void append_int(T n, memory_buf_t &dest)
+{
+    // Buffer should be large enough to hold all digits (digits10 + 1) and a sign
+    SPDLOG_CONSTEXPR const auto BUF_SIZE = std::numeric_limits<T>::digits10 + 2;
+    char buf[BUF_SIZE];
+
+    auto [ptr, ec] = std::to_chars(buf, buf + BUF_SIZE, n, 10);
+    if (ec == std::errc())
+    {
+        dest.append(buf, ptr);
+    }
+    else
+    {
+        throw_spdlog_ex("Failed to format int", static_cast<int>(ec));
+    }
+}
+#else
 template<typename T>
 inline void append_int(T n, memory_buf_t &dest)
 {
     fmt::format_int i(n);
     dest.append(i.data(), i.data() + i.size());
 }
+#endif
+
+template<typename T>
+SPDLOG_CONSTEXPR_FUNC unsigned int count_digits_fallback(T n)
+{
+    // taken from fmt: https://github.com/fmtlib/fmt/blob/8.0.1/include/fmt/format.h#L899-L912
+    unsigned int count = 1;
+    for (;;)
+    {
+        // Integer division is slow so do it for a group of four digits instead
+        // of for every digit. The idea comes from the talk by Alexandrescu
+        // "Three Optimization Tips for C++". See speed-test for a comparison.
+        if (n < 10)
+            return count;
+        if (n < 100)
+            return count + 1;
+        if (n < 1000)
+            return count + 2;
+        if (n < 10000)
+            return count + 3;
+        n /= 10000u;
+        count += 4;
+    }
+}
 
 template<typename T>
 inline unsigned int count_digits(T n)
 {
     using count_type = typename std::conditional<(sizeof(T) > sizeof(uint32_t)), uint64_t, uint32_t>::type;
+#ifdef SPDLOG_USE_STD_FORMAT
+    return count_digits_fallback(static_cast<count_type>(n));
+#else
     return static_cast<unsigned int>(fmt::
 // fmt 7.0.0 renamed the internal namespace to detail.
 // See: https://github.com/fmtlib/fmt/issues/1538
-#if FMT_VERSION < 70000
+#    if FMT_VERSION < 70000
             internal
-#else
+#    else
             detail
-#endif
+#    endif
         ::count_digits(static_cast<count_type>(n)));
+#endif
 }
 
 inline void pad2(int n, memory_buf_t &dest)
@@ -55,7 +107,7 @@ inline void pad2(int n, memory_buf_t &dest)
     }
     else // unlikely, but just in case, let fmt deal with it
     {
-        fmt::format_to(std::back_inserter(dest), SPDLOG_FMT_RUNTIME("{:02}"), n);
+        fmt_lib::format_to(std::back_inserter(dest), SPDLOG_FMT_STRING("{:02}"), n);
     }
 }
 

thirdparty/spdlog/details/mpmc_blocking_q.h

@@ -49,7 +49,7 @@ public:
         push_cv_.notify_one();
     }
 
-    // try to dequeue item. if no item found. wait upto timeout and try again
+    // try to dequeue item. if no item found. wait up to timeout and try again
     // Return true, if succeeded dequeue item, false otherwise
     bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
     {
@@ -87,7 +87,7 @@ public:
         push_cv_.notify_one();
     }
 
-    // try to dequeue item. if no item found. wait upto timeout and try again
+    // try to dequeue item. if no item found. wait up to timeout and try again
     // Return true, if succeeded dequeue item, false otherwise
     bool dequeue_for(T &popped_item, std::chrono::milliseconds wait_duration)
     {
@@ -116,6 +116,12 @@ public:
         return q_.size();
     }
 
+    void reset_overrun_counter()
+    {
+        std::unique_lock<std::mutex> lock(queue_mutex_);
+        q_.reset_overrun_counter();
+    }
+
 private:
     std::mutex queue_mutex_;
     std::condition_variable push_cv_;

thirdparty/spdlog/details/null_mutex.h

@@ -13,10 +13,6 @@ struct null_mutex
 {
     void lock() const {}
     void unlock() const {}
-    bool try_lock() const
-    {
-        return true;
-    }
 };
 
 struct null_atomic_int

thirdparty/spdlog/details/os-inl.h

@@ -46,7 +46,7 @@
 #        include <sys/syscall.h> //Use gettid() syscall under linux to get thread id
 
 #    elif defined(_AIX)
-#        include <pthread.h> // for pthread_getthreadid_np
+#        include <pthread.h> // for pthread_getthrds_np
 
 #    elif defined(__DragonFly__) || defined(__FreeBSD__)
 #        include <pthread_np.h> // for pthread_getthreadid_np
@@ -145,7 +145,7 @@ SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename
     const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644));
     if (fd == -1)
     {
-        return false;
+        return true;
     }
     *fp = ::fdopen(fd, mode.c_str());
     if (*fp == nullptr)
@@ -230,8 +230,8 @@ SPDLOG_INLINE size_t filesize(FILE *f)
 #    endif
 
 #else // unix
-// OpenBSD doesn't compile with :: before the fileno(..)
-#    if defined(__OpenBSD__)
+// OpenBSD and AIX doesn't compile with :: before the fileno(..)
+#    if defined(__OpenBSD__) || defined(_AIX)
     int fd = fileno(f);
 #    else
     int fd = ::fileno(f);
@@ -305,7 +305,7 @@ SPDLOG_INLINE int utc_minutes_offset(const std::tm &tm)
                 ((local_year / 100 >> 2) - (gmt_year / 100 >> 2))
 
                 // + difference in years * 365 */
-                + (long int)(local_year - gmt_year) * 365);
+                + static_cast<long int>(local_year - gmt_year) * 365);
 
             long int hours = (24 * days) + (localtm.tm_hour - gmtm.tm_hour);
             long int mins = (60 * hours) + (localtm.tm_min - gmtm.tm_min);
@@ -336,7 +336,14 @@ SPDLOG_INLINE size_t _thread_id() SPDLOG_NOEXCEPT
 #        define SYS_gettid __NR_gettid
 #    endif
     return static_cast<size_t>(::syscall(SYS_gettid));
-#elif defined(_AIX) || defined(__DragonFly__) || defined(__FreeBSD__)
+#elif defined(_AIX)
+    struct __pthrdsinfo buf;
+    int reg_size = 0;
+    pthread_t pt = pthread_self();
+    int retval = pthread_getthrds_np(&pt, PTHRDSINFO_QUERY_TID, &buf, sizeof(buf), NULL, &reg_size);
+    int tid = (!retval) ? buf.__pi_tid : 0;
+    return static_cast<size_t>(tid);
+#elif defined(__DragonFly__) || defined(__FreeBSD__)
     return static_cast<size_t>(::pthread_getthreadid_np());
 #elif defined(__NetBSD__)
     return static_cast<size_t>(::_lwp_self());
@@ -381,7 +388,7 @@ SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
 {
     memory_buf_t buf;
     wstr_to_utf8buf(filename, buf);
-    return fmt::to_string(buf);
+    return SPDLOG_BUF_TO_STRING(buf);
 }
 #else
 SPDLOG_INLINE std::string filename_to_str(const filename_t &filename)
@@ -394,9 +401,9 @@ SPDLOG_INLINE int pid() SPDLOG_NOEXCEPT
 {
 
 #ifdef _WIN32
-    return static_cast<int>(::GetCurrentProcessId());
+    return conditional_static_cast<int>(::GetCurrentProcessId());
 #else
-    return static_cast<int>(::getpid());
+    return conditional_static_cast<int>(::getpid());
 #endif
 }
 
@@ -476,7 +483,7 @@ SPDLOG_INLINE void wstr_to_utf8buf(wstring_view_t wstr, memory_buf_t &target)
         }
     }
 
-    throw_spdlog_ex(fmt::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
+    throw_spdlog_ex(fmt_lib::format("WideCharToMultiByte failed. Last error: {}", ::GetLastError()));
 }
 
 SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
@@ -511,7 +518,7 @@ SPDLOG_INLINE void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target)
         }
     }
 
-    throw_spdlog_ex(fmt::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
+    throw_spdlog_ex(fmt_lib::format("MultiByteToWideChar failed. Last error: {}", ::GetLastError()));
 }
 #endif // (defined(SPDLOG_WCHAR_TO_UTF8_SUPPORT) || defined(SPDLOG_WCHAR_FILENAMES)) && defined(_WIN32)
 
@@ -531,7 +538,7 @@ static SPDLOG_INLINE bool mkdir_(const filename_t &path)
 
 // create the given directory - and all directories leading to it
 // return true on success or if the directory already exists
-SPDLOG_INLINE bool create_dir(filename_t path)
+SPDLOG_INLINE bool create_dir(const filename_t &path)
 {
     if (path_exists(path))
     {
@@ -570,7 +577,7 @@ SPDLOG_INLINE bool create_dir(filename_t path)
 // "abc/" => "abc"
 // "abc" => ""
 // "abc///" => "abc//"
-SPDLOG_INLINE filename_t dir_name(filename_t path)
+SPDLOG_INLINE filename_t dir_name(const filename_t &path)
 {
     auto pos = path.find_last_of(folder_seps_filename);
     return pos != filename_t::npos ? path.substr(0, pos) : filename_t{};

thirdparty/spdlog/details/os.h

@@ -99,11 +99,11 @@ SPDLOG_API void utf8_to_wstrbuf(string_view_t str, wmemory_buf_t &target);
 // "abc/" => "abc"
 // "abc" => ""
 // "abc///" => "abc//"
-SPDLOG_API filename_t dir_name(filename_t path);
+SPDLOG_API filename_t dir_name(const filename_t &path);
 
 // Create a dir from the given path.
 // Return true if succeeded or if this dir already exists.
-SPDLOG_API bool create_dir(filename_t path);
+SPDLOG_API bool create_dir(const filename_t &path);
 
 // non thread safe, cross platform getenv/getenv_s
 // return empty string if field not found

thirdparty/spdlog/details/periodic_worker-inl.h

@@ -10,27 +10,6 @@
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE periodic_worker::periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval)
-{
-    active_ = (interval > std::chrono::seconds::zero());
-    if (!active_)
-    {
-        return;
-    }
-
-    worker_thread_ = std::thread([this, callback_fun, interval]() {
-        for (;;)
-        {
-            std::unique_lock<std::mutex> lock(this->mutex_);
-            if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
-            {
-                return; // active_ == false, so exit this thread
-            }
-            callback_fun();
-        }
-    });
-}
-
 // stop the worker thread and join it
 SPDLOG_INLINE periodic_worker::~periodic_worker()
 {

thirdparty/spdlog/details/periodic_worker.h

@@ -20,7 +20,27 @@ namespace details {
 class SPDLOG_API periodic_worker
 {
 public:
-    periodic_worker(const std::function<void()> &callback_fun, std::chrono::seconds interval);
+    template<typename Rep, typename Period>
+    periodic_worker(const std::function<void()> &callback_fun, std::chrono::duration<Rep, Period> interval)
+    {
+        active_ = (interval > std::chrono::duration<Rep, Period>::zero());
+        if (!active_)
+        {
+            return;
+        }
+
+        worker_thread_ = std::thread([this, callback_fun, interval]() {
+            for (;;)
+            {
+                std::unique_lock<std::mutex> lock(this->mutex_);
+                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
+                {
+                    return; // active_ == false, so exit this thread
+                }
+                callback_fun();
+            }
+        });
+    }
     periodic_worker(const periodic_worker &) = delete;
     periodic_worker &operator=(const periodic_worker &) = delete;
     // stop the worker thread and join it

thirdparty/spdlog/details/registry-inl.h

@@ -188,13 +188,6 @@ SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
     flush_level_ = log_level;
 }
 
-SPDLOG_INLINE void registry::flush_every(std::chrono::seconds interval)
-{
-    std::lock_guard<std::mutex> lock(flusher_mutex_);
-    auto clbk = [this]() { this->flush_all(); };
-    periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
-}
-
 SPDLOG_INLINE void registry::set_error_handler(err_handler handler)
 {
     std::lock_guard<std::mutex> lock(logger_map_mutex_);

thirdparty/spdlog/details/registry.h

@@ -9,6 +9,7 @@
 // This class is thread safe
 
 #include <spdlog/common.h>
+#include <spdlog/details/periodic_worker.h>
 
 #include <chrono>
 #include <functional>
@@ -22,7 +23,6 @@ class logger;
 
 namespace details {
 class thread_pool;
-class periodic_worker;
 
 class SPDLOG_API registry
 {
@@ -61,7 +61,13 @@ public:
 
     void flush_on(level::level_enum log_level);
 
-    void flush_every(std::chrono::seconds interval);
+    template<typename Rep, typename Period>
+    void flush_every(std::chrono::duration<Rep, Period> interval)
+    {
+        std::lock_guard<std::mutex> lock(flusher_mutex_);
+        auto clbk = [this]() { this->flush_all(); };
+        periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
+    }
 
     void set_error_handler(err_handler handler);
 

thirdparty/spdlog/details/synchronous_factory.h

@@ -13,7 +13,7 @@ class logger;
 struct synchronous_factory
 {
     template<typename Sink, typename... SinkArgs>
-    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&...args)
+    static std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs &&... args)
     {
         auto sink = std::make_shared<Sink>(std::forward<SinkArgs>(args)...);
         auto new_logger = std::make_shared<spdlog::logger>(std::move(logger_name), std::move(sink));

thirdparty/spdlog/details/tcp_client-windows.h

@@ -25,20 +25,6 @@ class tcp_client
 {
     SOCKET socket_ = INVALID_SOCKET;
 
-    static bool winsock_initialized_()
-    {
-        SOCKET s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
-        if (s == INVALID_SOCKET)
-        {
-            return false;
-        }
-        else
-        {
-            closesocket(s);
-            return true;
-        }
-    }
-
     static void init_winsock_()
     {
         WSADATA wsaData;
@@ -52,13 +38,24 @@ class tcp_client
     static void throw_winsock_error_(const std::string &msg, int last_error)
     {
         char buf[512];
-        ::FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
             MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
 
-        throw_spdlog_ex(fmt::format("tcp_sink - {}: {}", msg, buf));
+        throw_spdlog_ex(fmt_lib::format("tcp_sink - {}: {}", msg, buf));
     }
 
 public:
+    tcp_client()
+    {
+        init_winsock_();
+    }
+
+    ~tcp_client()
+    {
+        close();
+        ::WSACleanup();
+    }
+
     bool is_connected() const
     {
         return socket_ != INVALID_SOCKET;
@@ -68,7 +65,6 @@ public:
     {
         ::closesocket(socket_);
         socket_ = INVALID_SOCKET;
-        WSACleanup();
     }
 
     SOCKET fd() const
@@ -76,20 +72,9 @@ public:
         return socket_;
     }
 
-    ~tcp_client()
-    {
-        close();
-    }
-
     // try to connect or throw on failure
     void connect(const std::string &host, int port)
     {
-        // initialize winsock if needed
-        if (!winsock_initialized_())
-        {
-            init_winsock_();
-        }
-
         if (is_connected())
         {
             close();

thirdparty/spdlog/details/tcp_client.h

@@ -67,8 +67,7 @@ public:
         auto rv = ::getaddrinfo(host.c_str(), port_str.c_str(), &hints, &addrinfo_result);
         if (rv != 0)
         {
-            auto msg = fmt::format("::getaddrinfo failed: {}", gai_strerror(rv));
-            throw_spdlog_ex(msg);
+            throw_spdlog_ex(fmt_lib::format("::getaddrinfo failed: {}", gai_strerror(rv)));
         }
 
         // Try each address until we successfully connect(2).

thirdparty/spdlog/details/thread_pool-inl.h

@@ -13,7 +13,8 @@
 namespace spdlog {
 namespace details {
 
-SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
+SPDLOG_INLINE thread_pool::thread_pool(
+    size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop)
     : q_(q_max_items)
 {
     if (threads_n == 0 || threads_n > 1000)
@@ -23,15 +24,21 @@ SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std
     }
     for (size_t i = 0; i < threads_n; i++)
     {
-        threads_.emplace_back([this, on_thread_start] {
+        threads_.emplace_back([this, on_thread_start, on_thread_stop] {
             on_thread_start();
             this->thread_pool::worker_loop_();
+            on_thread_stop();
         });
     }
 }
 
+SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start)
+    : thread_pool(q_max_items, threads_n, on_thread_start, [] {})
+{}
+
 SPDLOG_INLINE thread_pool::thread_pool(size_t q_max_items, size_t threads_n)
-    : thread_pool(q_max_items, threads_n, [] {})
+    : thread_pool(
+          q_max_items, threads_n, [] {}, [] {})
 {}
 
 // message all threads to terminate gracefully join them
@@ -68,6 +75,11 @@ size_t SPDLOG_INLINE thread_pool::overrun_counter()
     return q_.overrun_counter();
 }
 
+void SPDLOG_INLINE thread_pool::reset_overrun_counter()
+{
+    q_.reset_overrun_counter();
+}
+
 size_t SPDLOG_INLINE thread_pool::queue_size()
 {
     return q_.size();

thirdparty/spdlog/details/thread_pool.h

@@ -84,10 +84,11 @@ public:
     using item_type = async_msg;
     using q_type = details::mpmc_blocking_queue<item_type>;
 
+    thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start, std::function<void()> on_thread_stop);
     thread_pool(size_t q_max_items, size_t threads_n, std::function<void()> on_thread_start);
     thread_pool(size_t q_max_items, size_t threads_n);
 
-    // message all threads to terminate gracefully join them
+    // message all threads to terminate gracefully and join them
     ~thread_pool();
 
     thread_pool(const thread_pool &) = delete;
@@ -96,6 +97,7 @@ public:
     void post_log(async_logger_ptr &&worker_ptr, const details::log_msg &msg, async_overflow_policy overflow_policy);
     void post_flush(async_logger_ptr &&worker_ptr, async_overflow_policy overflow_policy);
     size_t overrun_counter();
+    void reset_overrun_counter();
     size_t queue_size();
 
 private:

thirdparty/spdlog/details/udp_client-windows.h

@@ -0,0 +1,111 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Helper RAII over winsock udp client socket.
+// Will throw on construction if socket creation failed.
+
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+#include <spdlog/details/windows_include.h>
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+
+#pragma comment(lib, "Ws2_32.lib")
+#pragma comment(lib, "Mswsock.lib")
+#pragma comment(lib, "AdvApi32.lib")
+
+namespace spdlog {
+namespace details {
+class udp_client
+{
+    static constexpr int TX_BUFFER_SIZE = 1024 * 10;
+    SOCKET socket_ = INVALID_SOCKET;
+    sockaddr_in addr_ = {0};
+
+    static void init_winsock_()
+    {
+        WSADATA wsaData;
+        auto rv = ::WSAStartup(MAKEWORD(2, 2), &wsaData);
+        if (rv != 0)
+        {
+            throw_winsock_error_("WSAStartup failed", ::WSAGetLastError());
+        }
+    }
+
+    static void throw_winsock_error_(const std::string &msg, int last_error)
+    {
+        char buf[512];
+        ::FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, last_error,
+            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, (sizeof(buf) / sizeof(char)), NULL);
+
+        throw_spdlog_ex(fmt_lib::format("udp_sink - {}: {}", msg, buf));
+    }
+
+    void cleanup_()
+    {
+        if (socket_ != INVALID_SOCKET)
+        {
+            ::closesocket(socket_);
+        }
+        socket_ = INVALID_SOCKET;
+        ::WSACleanup();
+    }
+
+public:
+    udp_client(const std::string &host, uint16_t port)
+    {
+        init_winsock_();
+
+        addr_.sin_family = PF_INET;
+        addr_.sin_port = htons(port);
+        addr_.sin_addr.s_addr = INADDR_ANY;
+        if (InetPtonA(PF_INET, host.c_str(), &addr_.sin_addr.s_addr) != 1)
+        {
+            int last_error = ::WSAGetLastError();
+            ::WSACleanup();
+            throw_winsock_error_("error: Invalid address!", last_error);
+        }
+
+        socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
+        if (socket_ == INVALID_SOCKET)
+        {
+            int last_error = ::WSAGetLastError();
+            ::WSACleanup();
+            throw_winsock_error_("error: Create Socket failed", last_error);
+        }
+
+        int option_value = TX_BUFFER_SIZE;
+        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0)
+        {
+            int last_error = ::WSAGetLastError();
+            cleanup_();
+            throw_winsock_error_("error: setsockopt(SO_SNDBUF) Failed!", last_error);
+        }
+    }
+
+    ~udp_client()
+    {
+        cleanup_();
+    }
+
+    SOCKET fd() const
+    {
+        return socket_;
+    }
+
+    void send(const char *data, size_t n_bytes)
+    {
+        socklen_t tolen = sizeof(struct sockaddr);
+        if (::sendto(socket_, data, static_cast<int>(n_bytes), 0, (struct sockaddr *)&addr_, tolen) == -1)
+        {
+            throw_spdlog_ex("sendto(2) failed", errno);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog

thirdparty/spdlog/details/udp_client.h

@@ -0,0 +1,94 @@
+// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
+// Distributed under the MIT License (http://opensource.org/licenses/MIT)
+
+#pragma once
+
+// Helper RAII over unix udp client socket.
+// Will throw on construction if the socket creation failed.
+
+#ifdef _WIN32
+#    error "include udp_client-windows.h instead"
+#endif
+
+#include <spdlog/common.h>
+#include <spdlog/details/os.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <netinet/udp.h>
+
+#include <string>
+
+namespace spdlog {
+namespace details {
+
+class udp_client
+{
+    static constexpr int TX_BUFFER_SIZE = 1024 * 10;
+    int socket_ = -1;
+    struct sockaddr_in sockAddr_;
+
+    void cleanup_()
+    {
+        if (socket_ != -1)
+        {
+            ::close(socket_);
+            socket_ = -1;
+        }
+    }
+
+public:
+    udp_client(const std::string &host, uint16_t port)
+    {
+        socket_ = ::socket(PF_INET, SOCK_DGRAM, 0);
+        if (socket_ < 0)
+        {
+            throw_spdlog_ex("error: Create Socket Failed!");
+        }
+
+        int option_value = TX_BUFFER_SIZE;
+        if (::setsockopt(socket_, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<const char *>(&option_value), sizeof(option_value)) < 0)
+        {
+            cleanup_();
+            throw_spdlog_ex("error: setsockopt(SO_SNDBUF) Failed!");
+        }
+
+        sockAddr_.sin_family = AF_INET;
+        sockAddr_.sin_port = htons(port);
+
+        if (::inet_aton(host.c_str(), &sockAddr_.sin_addr) == 0)
+        {
+            cleanup_();
+            throw_spdlog_ex("error: Invalid address!");
+        }
+
+        ::memset(sockAddr_.sin_zero, 0x00, sizeof(sockAddr_.sin_zero));
+    }
+
+    ~udp_client()
+    {
+        cleanup_();
+    }
+
+    int fd() const
+    {
+        return socket_;
+    }
+
+    // Send exactly n_bytes of the given data.
+    // On error close the connection and throw.
+    void send(const char *data, size_t n_bytes)
+    {
+        ssize_t toslen = 0;
+        socklen_t tolen = sizeof(struct sockaddr);
+        if ((toslen = ::sendto(socket_, data, n_bytes, 0, (struct sockaddr *)&sockAddr_, tolen)) == -1)
+        {
+            throw_spdlog_ex("sendto(2) failed", errno);
+        }
+    }
+};
+} // namespace details
+} // namespace spdlog