spdlog

include/spdlog/sinks/async_sink.h

@@ -0,0 +1,137 @@
+#pragma once
+
+#include <thread>
+#include <chrono>
+#include <atomic>
+#include <algorithm>
+
+#include "./base_sink.h"
+#include "../logger.h"
+#include "../details/blocking_queue.h"
+#include "../details/null_mutex.h"
+#include "../details/log_msg.h"
+
+#include<iostream>
+
+namespace spdlog
+{
+namespace sinks
+{
+
+class async_sink : public base_sink<details::null_mutex>
+{
+public:
+    using q_type = details::blocking_queue<details::log_msg>;
+
+    explicit async_sink(const q_type::size_type max_queue_size);
+
+    //Stop logging and join the back thread
+    ~async_sink();
+    void add_sink(sink_ptr sink);
+    void remove_sink(sink_ptr sink_ptr);
+    q_type& q();
+    //Wait to remaining items (if any) in the queue to be written and shutdown
+    void shutdown(const std::chrono::milliseconds& timeout);
+
+
+protected:
+    void _sink_it(const details::log_msg& msg) override;
+    void _thread_loop();
+
+private:
+    std::vector<std::shared_ptr<sink>> _sinks;
+    std::atomic<bool> _active;
+    q_type _q;
+    std::thread _back_thread;
+    //Clear all remaining messages(if any), stop the _back_thread and join it
+    void _shutdown();
+    std::mutex _mutex;
+};
+}
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// async_sink class implementation
+///////////////////////////////////////////////////////////////////////////////
+inline spdlog::sinks::async_sink::async_sink(const q_type::size_type max_queue_size)
+    :_sinks(),
+     _active(true),
+     _q(max_queue_size),
+     _back_thread(&async_sink::_thread_loop, this)
+{}
+
+inline spdlog::sinks::async_sink::~async_sink()
+{
+    _shutdown();
+}
+
+inline void spdlog::sinks::async_sink::_sink_it(const details::log_msg& msg)
+{
+    if(!_active)
+        return;
+    _q.push(msg);
+}
+
+inline void spdlog::sinks::async_sink::_thread_loop()
+{
+    static std::chrono::seconds  pop_timeout { 1 };
+    while (_active)
+    {
+        q_type::item_type msg;
+        if (_q.pop(msg, pop_timeout))
+        {
+            for (auto &s : _sinks)
+            {
+                s->log(msg);
+                if(!_active)
+                    break;
+            }
+        }
+    }
+}
+
+inline void spdlog::sinks::async_sink::add_sink(spdlog::sink_ptr s)
+{
+    std::lock_guard<std::mutex> guard(_mutex);
+    _sinks.push_back(s);
+}
+
+
+inline void spdlog::sinks::async_sink::remove_sink(spdlog::sink_ptr s)
+{
+    std::lock_guard<std::mutex> guard(_mutex);
+    _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), s), _sinks.end());
+}
+
+
+inline spdlog::sinks::async_sink::q_type& spdlog::sinks::async_sink::q()
+{
+    return _q;
+}
+
+
+inline void spdlog::sinks::async_sink::shutdown(const std::chrono::milliseconds& timeout)
+{
+    if(timeout > std::chrono::milliseconds::zero())
+    {
+        auto until = log_clock::now() + timeout;
+        while (_q.size() > 0 && log_clock::now() < until)
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(2));
+        }
+    }
+    _shutdown();
+}
+
+
+inline void spdlog::sinks::async_sink::_shutdown()
+{
+    std::lock_guard<std::mutex> guard(_mutex);
+    if(_active)
+    {
+        _active = false;
+        if (_back_thread.joinable())
+            _back_thread.join();
+    }
+}
+

include/spdlog/sinks/base_sink.h

@@ -0,0 +1,43 @@
+#pragma once
+//
+// base sink templated over a mutex (either dummy or realy)
+// concrete implementation should only overrid the _sink_it method.
+// all locking is taken care of here so no locking needed by the implementors..
+//
+
+#include<string>
+#include<mutex>
+#include<atomic>
+#include "./sink.h"
+#include "../formatter.h"
+#include "../common.h"
+#include "../details/log_msg.h"
+
+
+namespace spdlog
+{
+namespace sinks
+{
+template<class Mutex>
+class base_sink:public sink
+{
+public:
+    base_sink():_mutex() {}
+    virtual ~base_sink() = default;
+
+    base_sink(const base_sink&) = delete;
+    base_sink& operator=(const base_sink&) = delete;
+
+    void log(const details::log_msg& msg) override
+    {
+        std::lock_guard<Mutex> lock(_mutex);
+        _sink_it(msg);
+    };
+
+
+protected:
+    virtual void _sink_it(const details::log_msg& msg) = 0;
+    Mutex _mutex;
+};
+}
+}

include/spdlog/sinks/file_sinks.h

@@ -0,0 +1,189 @@
+#pragma once
+
+
+#include <mutex>
+#include "./base_sink.h"
+
+#include "../details/null_mutex.h"
+#include "../details/file_helper.h"
+#include "../details/fast_oss.h"
+
+
+
+namespace spdlog
+{
+namespace sinks
+{
+
+/*
+* Trivial file sink with single file as target
+*/
+template<class Mutex>
+class simple_file_sink : public base_sink<Mutex>
+{
+public:
+    explicit simple_file_sink(const std::string &filename,
+                              const std::size_t flush_inverval=0):
+        _file_helper(flush_inverval)
+    {
+        _file_helper.open(filename);
+    }
+protected:
+    void _sink_it(const details::log_msg& msg) override
+    {
+        _file_helper.write(msg);
+    }
+private:
+    details::file_helper _file_helper;
+};
+
+typedef simple_file_sink<std::mutex> simple_file_sink_mt;
+typedef simple_file_sink<details::null_mutex> simple_file_sink_st;
+
+/*
+ * Rotating file sink based on size
+*/
+template<class Mutex>
+class rotating_file_sink : public base_sink<Mutex>
+{
+public:
+    rotating_file_sink(const std::string &base_filename, const std::string &extension,
+                       const std::size_t max_size, const std::size_t max_files,
+                       const std::size_t flush_inverval=0):
+        _base_filename(base_filename),
+        _extension(extension),
+        _max_size(max_size),
+        _max_files(max_files),
+        _current_size(0),
+        _file_helper(flush_inverval)
+    {
+        _file_helper.open(calc_filename(_base_filename, 0, _extension));
+    }
+
+protected:
+    void _sink_it(const details::log_msg& msg) override
+    {
+        _current_size += msg.formatted.size();
+        if (_current_size  > _max_size)
+        {
+            _rotate();
+            _current_size = msg.formatted.size();
+        }
+        _file_helper.write(msg);
+    }
+
+
+private:
+    static std::string calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
+    {
+        details::fast_oss oss;
+        if (index)
+            oss << filename << "." << index << "." << extension;
+        else
+            oss << filename << "." << extension;
+        return oss.str();
+    }
+
+
+    // Rotate files:
+    // log.txt -> log.1.txt
+    // log.1.txt -> log2.txt
+    // log.2.txt -> log3.txt
+    // log.3.txt -> delete
+
+
+    void _rotate()
+    {
+        _file_helper.close();
+        for (auto i = _max_files; i > 0; --i)
+        {
+            std::string src = calc_filename(_base_filename, i - 1, _extension);
+            std::string target = calc_filename(_base_filename, i, _extension);
+
+            if (details::file_helper::file_exists(target))
+                std::remove(target.c_str());
+            if (details::file_helper::file_exists(src) && std::rename(src.c_str(), target.c_str()))
+            {
+                throw fflog_exception("rotating_file_sink: failed renaming " + src + " to " + target);
+            }
+        }
+        auto cur_name = _file_helper.filename();
+        std::remove(cur_name.c_str());
+        _file_helper.open(cur_name);
+    }
+    std::string _base_filename;
+    std::string _extension;
+    std::size_t _max_size;
+    std::size_t _max_files;
+    std::size_t _current_size;
+    details::file_helper _file_helper;
+};
+
+typedef rotating_file_sink<std::mutex> rotating_file_sink_mt;
+typedef rotating_file_sink<details::null_mutex>rotating_file_sink_st;
+
+/*
+ * Rotating file sink based on date. rotates at midnight
+ */
+template<class Mutex>
+class daily_file_sink:public base_sink<Mutex>
+{
+public:
+    explicit daily_file_sink(const std::string& base_filename,
+                             const std::string& extension,
+                             const std::size_t flush_inverval=0):
+        _base_filename(base_filename),
+        _extension(extension),
+        _midnight_tp (_calc_midnight_tp() ),
+        _file_helper(flush_inverval)
+    {
+        _file_helper.open(calc_filename(_base_filename, _extension));
+    }
+
+protected:
+    void _sink_it(const details::log_msg& msg) override
+    {
+        if (std::chrono::system_clock::now() >= _midnight_tp)
+        {
+            _file_helper.close();
+            _file_helper.open(calc_filename(_base_filename, _extension));
+            _midnight_tp = _calc_midnight_tp();
+        }
+        _file_helper.write(msg);
+    }
+
+private:
+    // Return next midnight's time_point
+    static std::chrono::system_clock::time_point _calc_midnight_tp()
+    {
+        using namespace std::chrono;
+        auto now = system_clock::now();
+        time_t tnow = std::chrono::system_clock::to_time_t(now);
+        tm date = spdlog::details::os::localtime(tnow);
+        date.tm_hour = date.tm_min = date.tm_sec = 0;
+        auto midnight = std::chrono::system_clock::from_time_t(std::mktime(&date));
+        return system_clock::time_point(midnight + hours(24));
+    }
+
+    //Create filename for the form basename.YYYY-MM-DD.extension
+    static std::string calc_filename(const std::string& basename, const std::string& extension)
+    {
+        std::tm tm = spdlog::details::os::localtime();
+        details::fast_oss oss;
+        oss << basename << '.';
+        oss << tm.tm_year + 1900 << '-' << std::setw(2) << std::setfill('0') << tm.tm_mon + 1 << '-' << tm.tm_mday;
+        oss << '.' << extension;
+        return oss.str();
+    }
+
+    std::string _base_filename;
+    std::string _extension;
+    std::chrono::system_clock::time_point _midnight_tp;
+    details::file_helper _file_helper;
+
+};
+
+typedef daily_file_sink<std::mutex> daily_file_sink_mt;
+typedef daily_file_sink<details::null_mutex> daily_file_sink_st;
+}
+}

include/spdlog/sinks/null_sink.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <mutex>
+#include "./base_sink.h"
+#include "../details/null_mutex.h"
+
+
+namespace spdlog {
+namespace sinks {
+
+template <class Mutex>
+class null_sink : public base_sink<Mutex>
+{
+protected:
+    void _sink_it(const details::log_msg&) override
+    {}
+};
+
+typedef null_sink<details::null_mutex> null_sink_st;
+typedef null_sink<std::mutex> null_sink_mt;
+
+}
+}
+

include/spdlog/sinks/ostream_sink.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <iostream>
+#include <mutex>
+#include <memory>
+
+#include "../details/null_mutex.h"
+#include "./base_sink.h"
+
+namespace spdlog
+{
+namespace sinks
+{
+template<class Mutex>
+class ostream_sink: public base_sink<Mutex>
+{
+public:
+    explicit ostream_sink(std::ostream& os) :_ostream(os) {}
+    ostream_sink(const ostream_sink&) = delete;
+    ostream_sink& operator=(const ostream_sink&) = delete;
+    virtual ~ostream_sink() = default;
+
+
+protected:
+    virtual void _sink_it(const details::log_msg& msg) override
+    {
+        auto& buf = msg.formatted.buf();
+        _ostream.write(buf.data(), buf.size());
+    }
+    std::ostream& _ostream;
+};
+
+typedef ostream_sink<std::mutex> ostream_sink_mt;
+typedef ostream_sink<details::null_mutex> ostream_sink_st;
+}
+}

include/spdlog/sinks/sink.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "../details/log_msg.h"
+
+namespace spdlog
+{
+namespace sinks
+{
+class sink
+{
+public:
+    virtual ~sink() {}
+    virtual void log(const details::log_msg& msg) = 0;
+};
+}
+}
+

include/spdlog/sinks/stdout_sinks.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <iostream>
+#include <mutex>
+#include "./ostream_sink.h"
+#include "../details/null_mutex.h"
+
+namespace spdlog
+{
+namespace sinks
+{
+
+template <class Mutex>
+class stdout_sink : public ostream_sink<Mutex>
+{
+public:
+    stdout_sink() : ostream_sink<Mutex>(std::cout) {}
+};
+
+typedef stdout_sink<details::null_mutex> stdout_sink_st;
+typedef stdout_sink<std::mutex> stdout_sink_mt;
+
+
+template <class Mutex>
+class stderr_sink : public ostream_sink<Mutex>
+{
+public:
+    stderr_sink() : ostream_sink<Mutex>(std::cerr) {}
+};
+
+typedef stderr_sink<std::mutex> stderr_sink_mt;
+typedef stderr_sink<details::null_mutex> stderr_sink_st;
+}
+}