Initial import

include/c11log/details/blocking_queue.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <cstddef>
+#include <chrono>
+#include <memory>
+#include <queue>
+#include <mutex>
+#include <condition_variable>
+
+namespace c11log {
+namespace details {
+
+template<typename T>
+class blocking_queue {
+public:
+    explicit blocking_queue(std::size_t max_size) :_max_size(max_size), _q()
+    {}
+    blocking_queue(const blocking_queue&) = delete;
+    blocking_queue& operator=(const blocking_queue&) = delete;
+    ~blocking_queue() = default;
+
+    std::size_t size()
+    {
+        std::lock_guard<std::mutex> lock(_mutex);
+        return _q.size();
+    }
+    bool push(const T& item, const std::chrono::milliseconds& timeout)
+    {
+        std::unique_lock<std::mutex> ul(_mutex);
+        if (_q.size() >= _max_size) {
+            if (_item_popped_cond.wait_for(ul, timeout) == std::cv_status::timeout || _q.size() >= _max_size)
+                return false;
+        }
+
+        _q.push(item);
+        if (_q.size() <= 1)
+            _item_pushed_cond.notify_all();
+
+        return true;
+    }
+    bool pop(T& item, const std::chrono::milliseconds& timeout)
+    {
+        std::unique_lock<std::mutex> ul(_mutex);
+        if (_q.empty()) {
+            if (_item_pushed_cond.wait_for(ul, timeout) == std::cv_status::timeout || _q.empty())
+                return false;
+        }
+        item = _q.front();
+        _q.pop();
+        if (_q.size() >= _max_size - 1)
+            _item_popped_cond.notify_all();
+
+        return true;
+    }
+private:
+    std::size_t _max_size;
+    std::queue<T> _q;
+    std::mutex _mutex;
+    std::condition_variable _item_pushed_cond;
+    std::condition_variable _item_popped_cond;
+};
+
+}
+}

include/c11log/details/factory.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <unordered_map>
+#include <string>
+#include <memory>
+#include <mutex>
+
+namespace c11log {
+class logger;
+namespace details {
+class factory {
+public:
+    typedef std::shared_ptr<c11log::logger>  logger_ptr;
+    typedef std::unordered_map<std::string, logger_ptr> logger_map;
+    logger_ptr get_logger(const std::string &name);
+    static c11log::details::factory& instance();
+private:
+    logger_map _loggers;
+    std::mutex _loggers_mutex;
+};
+}
+}

include/c11log/details/fast_oss.h

@@ -0,0 +1,76 @@
+#pragma once
+
+#include<streambuf>
+#include<string>
+namespace c11log {
+namespace details {
+
+class str_devicebuf:public std::streambuf {
+public:
+    str_devicebuf()
+    {
+        _str.reserve(128);
+    }
+
+    const std::string& str_ref()
+    {
+        return _str;
+    }
+
+    void clear()
+    {
+        _str.clear();
+    }
+
+protected:
+    virtual int sync() override
+    {
+        return 0;
+    }
+
+    virtual std::streamsize xsputn(const char_type* s, std::streamsize count) override
+    {
+        _str.append(s, static_cast<unsigned int>(count));
+        return count;
+    }
+
+    virtual int_type overflow(int_type ch) override
+    {
+        if (ch != traits_type::eof())
+            _str.append((char*)&ch, 1);
+        return 1;
+    }
+private:
+    std::string _str;
+};
+
+class fast_oss:public std::ostream {
+public:
+    fast_oss():std::ostream(&_dev)
+    {}
+    ~fast_oss()
+    {}
+
+    const std::string& str_ref() const
+    {
+        auto mydevice = static_cast<str_devicebuf*>(rdbuf());
+        return mydevice->str_ref();
+    }
+
+    const std::string str() const
+    {
+        auto mydevice = static_cast<str_devicebuf*>(rdbuf());
+        return mydevice->str_ref();
+    }
+
+    void clear()
+    {
+        auto mydevice = static_cast<str_devicebuf*>(rdbuf());
+        mydevice->clear();
+    }
+private:
+    str_devicebuf _dev;
+
+};
+}
+}

include/c11log/details/line_logger.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "../level.h"
+#include "fast_oss.h"
+
+namespace c11log {
+class logger;
+namespace details {
+
+class line_logger {
+public:
+    c11log::details::line_logger::line_logger(logger* callback_logger, level::level_enum msg_level);
+    c11log::details::line_logger::line_logger(logger* callback_logger):_callback_logger(nullptr) {};
+    ~line_logger();
+
+    template<typename T>
+    line_logger& operator<<(const T& msg)
+    {
+        if (_callback_logger)
+            _oss << msg;
+        return *this;
+    }
+
+private:
+    logger* _callback_logger;
+    details::fast_oss _oss;
+
+};
+} //Namespace details
+} // Namespace c11log

include/c11log/details/message.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <chrono>
+#include <string>
+#include "../level.h"
+
+namespace c11log {
+namespace details {
+struct message {
+    message(const std::string& logger_name,
+            level::level_enum log_level,
+            const std::chrono::system_clock::time_point time_p
+            , const std::string& msg) :
+        logger_name(logger_name),
+        log_level(log_level),
+        time_p(time_p),
+        msg(msg) {}
+
+    ~message() = default;
+    message(const message& other) = default;
+    message& operator=(const message& rhs) = default;
+
+
+    std::string logger_name;
+    level::level_enum log_level;
+    std::chrono::system_clock::time_point time_p;
+    std::string msg;
+};
+
+}
+}

include/c11log/details/null_mutex.h

@@ -0,0 +1,17 @@
+#pragma once
+
+namespace c11log{
+	namespace details{
+		struct null_mutex
+		{
+			void lock()
+			{}
+			void unlock()
+			{}
+			bool try_lock()
+			{
+				return true;
+			}
+		};
+	}
+}

include/c11log/details/os.h

@@ -0,0 +1,17 @@
+#pragma once
+#include<string>
+#include<cstdio>
+#include<ctime>
+
+namespace c11log
+{
+	namespace details
+	{
+		namespace os
+		{			
+			std::tm localtime(const std::time_t &time_t);			
+			std::tm localtime();
+			
+		}		
+	}
+}

include/c11log/formatters/formatters.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include<string>
+#include<chrono>
+#include<functional>
+#include <sstream>
+
+#include "../level.h"
+#include "../details/os.h"
+
+namespace c11log {
+namespace formatters {
+typedef std::chrono::system_clock::time_point timepoint;
+typedef std::function<std::string(const std::string& logger_name, const std::string&, level::level_enum, const timepoint&)> format_fn;
+void format_time(const timepoint& tp, std::ostream &dest);
+void format_time(std::ostream &dest);
+std::string to_hex(const unsigned char* buf, std::size_t size);
+
+class formatter {
+public:
+    formatter() {}
+    virtual ~formatter() {}
+    virtual void format_header(const std::string& logger_name, level::level_enum level, const timepoint& tp, std::ostream& dest) = 0;
+};
+
+
+class default_formatter: public formatter {
+public:
+    // Format: [2013-12-29 01:04:42.900] [logger_name:Info] Message body
+    void format_header(const std::string& logger_name, level::level_enum level, const timepoint& tp, std::ostream& dest) override
+    {
+        format_time(tp, dest);
+        dest << " [" <<  logger_name << ":" << c11log::level::to_str(level) << "] ";
+    }
+
+};
+} //namespace formatter
+} //namespace c11log

include/c11log/level.h

@@ -0,0 +1,24 @@
+#pragma once
+
+namespace c11log
+{
+	namespace level
+	{
+		typedef enum
+		{
+			DEBUG,
+			INFO,
+			WARNING,
+			ERROR,
+			FATAL,
+			NONE = 99
+		} level_enum;
+		const char* to_str(level_enum l);				
+	}
+}
+
+static const char* level_names[] { "Debug", "Info", "Warning", "Error", "Fatal" };
+inline const char* c11log::level::to_str(c11log::level::level_enum l)
+{
+	return level_names[l];
+}

include/c11log/log_exception.h

@@ -0,0 +1,46 @@
+#pragma once
+#include <sstream>
+#include <iostream>
+
+namespace c11log
+{
+	class log_exception :public std::exception
+	{
+	public:
+		log_exception() : _oss(), _msg()
+		{}
+
+		virtual ~log_exception()
+		{}
+
+		explicit log_exception(const std::string& msg) :_oss(msg, std::ostringstream::ate), _msg(msg)
+		{}
+
+		log_exception(const log_exception &other) :_oss(other._oss.str()), _msg(other._msg)
+		{}
+
+		log_exception& operator=(const log_exception& other)
+		{
+			_oss.str(other._oss.str());
+			_msg = other._msg;
+			return *this;
+		}
+
+		virtual const char* what() const throw () override
+		{
+			return _msg.c_str();
+		}
+
+		template<typename T>
+		log_exception& operator<<(const T& what)
+		{
+			_oss << what;
+			_msg = _oss.str();
+			return *this;
+		}
+
+	private:
+		std::ostringstream _oss;
+		std::string _msg;
+	};
+}

include/c11log/logger.h

@@ -0,0 +1,161 @@
+#pragma once
+
+#include<vector>
+#include<memory>
+#include<mutex>
+#include<atomic>
+#include <algorithm>
+
+#include "level.h"
+#include "sinks/base_sink.h"
+#include "details/line_logger.h"
+#include "details/factory.h"
+
+
+namespace c11log {
+
+class logger {
+public:
+
+    typedef std::shared_ptr<sinks::base_sink>  sink_ptr_t;
+    typedef std::vector<sink_ptr_t> sinks_vector_t;
+
+    explicit logger(const std::string& name) : _logger_name(name),
+        _formatter(std::make_unique<formatters::default_formatter>())
+    {
+        _atomic_level.store(level::INFO);
+    }
+
+    ~logger()
+    {
+    };
+
+    logger(const logger&) = delete;
+    logger& operator=(const logger&) = delete;
+
+    void set_name(const std::string& name);
+    const std::string& get_name();
+    void add_sink(sink_ptr_t sink_ptr);
+    void remove_sink(sink_ptr_t sink_ptr);
+    void set_formatter(std::unique_ptr<formatters::formatter> formatter);
+    void set_level(c11log::level::level_enum level);
+    c11log::level::level_enum get_level() const;
+    bool should_log(c11log::level::level_enum level) const;
+
+    details::line_logger log(level::level_enum level);
+    details::line_logger debug();
+    details::line_logger info();
+    details::line_logger warn();
+    details::line_logger error();
+    details::line_logger fatal();
+
+private:
+    friend details::line_logger;
+
+
+    std::string _logger_name = "";
+    std::unique_ptr<c11log::formatters::formatter> _formatter;
+    sinks_vector_t _sinks;
+    std::mutex _mutex;
+    std::atomic_int _atomic_level;
+
+    void _log_it(const std::string& msg);
+
+};
+
+logger& get_logger(const std::string& name);
+}
+
+/*
+Logger inline impl
+*/
+
+inline c11log::details::line_logger c11log::logger::log(c11log::level::level_enum msg_level)
+{
+
+    if (msg_level >= _atomic_level.load()) {
+        std::lock_guard<std::mutex> lock(_mutex);
+        return details::line_logger(this, msg_level);
+    } else {
+        return details::line_logger(nullptr);
+    }
+
+}
+
+inline c11log::details::line_logger c11log::logger::debug()
+{
+    return log(c11log::level::DEBUG);
+}
+inline c11log::details::line_logger c11log::logger::info()
+{
+    return log(c11log::level::INFO);
+}
+inline c11log::details::line_logger c11log::logger::warn()
+{
+    return log(c11log::level::WARNING);
+}
+inline c11log::details::line_logger c11log::logger::error()
+{
+    return log(level::ERROR);
+}
+inline c11log::details::line_logger c11log::logger::fatal()
+{
+    return log(c11log::level::FATAL);
+}
+
+inline void c11log::logger::set_name(const std::string& name)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    _logger_name = name;
+}
+
+inline const std::string& c11log::logger::get_name()
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    return _logger_name;
+}
+
+inline void c11log::logger::add_sink(sink_ptr_t sink_ptr)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    _sinks.push_back(sink_ptr);
+}
+
+inline void c11log::logger::remove_sink(sink_ptr_t sink_ptr)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    _sinks.erase(std::remove(_sinks.begin(), _sinks.end(), sink_ptr), _sinks.end());
+}
+
+inline void c11log::logger::set_formatter(std::unique_ptr<formatters::formatter> formatter)
+{
+    std::lock_guard<std::mutex> lock(_mutex);
+    _formatter = std::move(formatter);
+}
+
+inline void c11log::logger::set_level(c11log::level::level_enum level)
+{
+    _atomic_level.store(level);
+}
+
+inline c11log::level::level_enum c11log::logger::get_level() const
+{
+    return static_cast<c11log::level::level_enum>(_atomic_level.load());
+}
+
+inline bool c11log::logger::should_log(c11log::level::level_enum level) const
+{
+    return level >= _atomic_level.load();
+}
+inline void c11log::logger::_log_it(const std::string& msg)
+{
+    level::level_enum level = static_cast<level::level_enum>(_atomic_level.load());
+    std::lock_guard<std::mutex> lock(_mutex);
+    for (auto &sink : _sinks)
+        sink->log(msg, level);
+}
+
+inline c11log::logger& c11log::get_logger(const std::string& name)
+{
+    return *(c11log::details::factory::instance().get_logger(name));
+}

include/c11log/sinks/async_sink.h

@@ -0,0 +1,55 @@
+#pragma once
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <iostream>
+
+#include "../logger.h"
+#include "base_sink.h"
+namespace c11log {
+namespace sinks {
+class async_sink : base_sink {
+    enum class fullq_policy {
+        BLOCK=0,
+        DROP_MSG
+    };
+public:
+    async_sink(std::size_t max_queue_size, fullq_policy q_policy) :_fullq_policy(q_policy), _back_thread(&_thread_loop)
+    {
+
+    }
+protected:
+    void _sink_it(const std::string& msg) override
+    {
+        _msgs_mutex.unlock();
+        _msgs.push(msg);
+    }
+    void _thread_loop()
+    {
+        while (_active) {
+            _msgs_mutex.lock();
+            std::string &msg = _msgs.front();
+            _msgs.pop();
+            _msgs_mutex.unlock();
+            std::cout << "Popped: " << msg << std::endl;
+        }
+    }
+
+private:
+    c11log::logger::sinks_vector_t _sinks;
+    fullq_policy _fullq_policy;
+    std::queue<std::string> _msgs;
+    std::thread _back_thread;
+    bool _active = true;
+    std::mutex _msgs_mutex;
+
+
+
+};
+}
+}
+
+void c11log::sinks::async_sink::_sink_it(const std::string& msg)
+{
+
+}

include/c11log/sinks/base_sink.h

@@ -0,0 +1,50 @@
+#pragma once
+#include<string>
+#include<memory>
+#include<mutex>
+
+#include "../formatters/formatters.h"
+#include "../level.h"
+
+namespace c11log {
+namespace sinks {
+class base_sink {
+public:
+    base_sink()
+    {}
+    base_sink(level::level_enum l):_level(l)
+    {};
+    virtual ~base_sink()
+    {};
+
+    base_sink(const base_sink&) = delete;
+    base_sink& operator=(const base_sink&) = delete;
+
+    void log(const std::string &msg, level::level_enum level)
+    {
+        if (level >= _level) {
+            std::lock_guard<std::mutex> lock(_mutex);
+            if (level >= _level)
+                _sink_it(msg);
+        }
+    };
+
+    void set_level(level::level_enum level)
+    {
+        std::lock_guard<std::mutex> lock(_mutex);
+        _level = level;
+    }
+
+protected:
+    virtual void _sink_it(const std::string& msg) = 0;
+    level::level_enum _level = level::INFO;
+    std::mutex _mutex;
+};
+
+class null_sink:public base_sink {
+protected:
+    void _sink_it(const std::string& msg) override
+    {}
+};
+}
+}

include/c11log/sinks/file_sinks.h

@@ -0,0 +1,174 @@
+#pragma once
+#include <fstream>
+#include  <iomanip>
+
+#include "../logger.h"
+#include "../log_exception.h"
+#include "../details/os.h"
+
+#include "base_sink.h"
+
+namespace c11log {
+namespace sinks {
+/*
+* Trivial file sink with single file as target
+*/
+class simple_file_sink:base_sink {
+public:
+    simple_file_sink(const std::string &filename, const std::string& extension = "txt")
+    {
+        std::ostringstream oss;
+        oss << filename << "." << extension;
+        _ofstream.open(oss.str(), std::ofstream::app);
+    }
+protected:
+    void _sink_it(const std::string& msg) override
+    {
+        _ofstream << msg;
+        _ofstream.flush();
+    }
+
+    std::ofstream _ofstream;
+};
+
+
+/*
+ * Rotating file sinks. Close and open new file at some point
+ */
+namespace details {
+class rotating_file_sink_base:public base_sink {
+public:
+    rotating_file_sink_base()
+    {}
+    virtual ~rotating_file_sink_base()
+    {}
+protected:
+    virtual void _sink_it(const std::string& msg) override
+    {
+        if (_should_rotate())
+            _rotate();
+        _ofstream << msg;
+        _ofstream.flush();
+    }
+    virtual bool _should_rotate() const = 0;
+    virtual void _rotate() = 0;
+    std::ofstream _ofstream;
+};
+}
+class rotating_file_sink:public details::rotating_file_sink_base {
+public:
+    rotating_file_sink(const std::string &base_filename, const std::string &extension, size_t max_size, size_t max_files):
+        _base_filename(base_filename),
+        _extension(extension),
+        _max_size(max_size),
+        _max_files(max_files),
+        _current_size(0),
+        _index(0)
+    {
+        _ofstream.open(_calc_filename(_base_filename, 0, _extension));
+    }
+
+protected:
+    virtual void _sink_it(const std::string& msg) override
+    {
+        _current_size += msg.length();
+        rotating_file_sink_base::_sink_it(msg);
+    }
+
+    bool _should_rotate() const override
+    {
+        return _current_size >= _max_size;
+    }
+
+    // Rotate old files:
+    // log.n-1.txt -> log.n.txt
+    // log n-2.txt -> log.n-1.txt
+    // ...
+    // log.txt -> log.1.txt
+    void _rotate() override
+    {
+        _ofstream.close();
+        _current_size = 0;
+        //Remove oldest file
+        for (auto i = _max_files; i > 0; --i) {
+            auto src = _calc_filename(_base_filename, i - 1, _extension);
+            auto target = _calc_filename(_base_filename, i, _extension);
+            if (i == _max_files)
+                std::remove(target.c_str());
+            std::rename(src.c_str(), target.c_str());
+        }
+
+        _ofstream.open(_calc_filename(_base_filename, 0, _extension));
+    }
+private:
+    static std::string _calc_filename(const std::string& filename, std::size_t index, const std::string& extension)
+    {
+        std::ostringstream oss;
+        if (index)
+            oss << filename << "." << index << "." << extension;
+        else
+            oss << filename << "." << extension;
+        return oss.str();
+    }
+    std::string _base_filename;
+    std::string _extension;
+    std::size_t _max_size;
+    std::size_t _max_files;
+    std::size_t _current_size;
+    std::size_t _index;
+
+};
+
+/*
+ * File sink that closes the log file at midnight and opens new one
+ */
+class midnight_file_sink:public details::rotating_file_sink_base {
+public:
+    midnight_file_sink(const std::string& base_filename, const std::string& extension):
+        _base_filename(base_filename),
+        _extension(extension),
+        _midnight_tp { _calc_midnight_tp() }
+
+    {
+        _ofstream.open(_calc_filename(_base_filename, _extension));
+    }
+
+protected:
+    bool _should_rotate() const override
+    {
+        return std::chrono::system_clock::now() >= _midnight_tp;
+    }
+    void _rotate() override
+    {
+        _midnight_tp = _calc_midnight_tp();
+        _ofstream.close();
+        _ofstream.open(_calc_filename(_base_filename, _extension));
+
+    }
+
+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 = c11log::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));
+    }
+
+    static std::string _calc_filename(const std::string& basename, const std::string& extension)
+    {
+        std::ostringstream oss;
+        std::tm now_tm = c11log::details::os::localtime();
+        oss << basename << std::put_time(&now_tm, ".%Y-%m-%d.") << extension;
+        return oss.str();
+    }
+    std::string _base_filename;
+    std::string _extension;
+    std::chrono::system_clock::time_point _midnight_tp;
+};
+}
+}

include/c11log/sinks/stdout_sinks.h

@@ -0,0 +1,41 @@
+
+#include <iostream>
+#include "base_sink.h"
+
+namespace c11log
+{
+	namespace sinks
+	{
+		class ostream_sink:public base_sink
+		{
+		public:
+			ostream_sink(std::ostream& os):_ostream(os)
+			{}
+
+			virtual ~ostream_sink()
+			{}
+
+		protected:
+			virtual void _sink_it(const std::string& msg)
+			{
+				_ostream << msg;
+			}
+			std::ostream& _ostream;
+
+		};
+
+		class stdout_sink:public ostream_sink
+		{
+		public:
+			stdout_sink():ostream_sink(std::cout)
+			{}
+		};
+
+		class stderr_sink:public ostream_sink
+		{
+		public:
+			stderr_sink():ostream_sink(std::cerr)
+			{}
+		};
+	}
+}