同步异步日志系统-日志器的实现

该模块是针对于前几个模块的整合，也是直接面向客户所使用的，对于该模块的实现，我们基于:继承+建造者设计模式来实现;
因此我们需要抽象出一个日志器抽象基类；
该基类提供的接口如下:
1、 debug();//站在用户的角度来说就是我只需要调用该接口就能完成debug版本日志消息的输出；但是站在日志器的角度来看就是，我日志器通过该接口先收集用户的日志信息，然后根据输出等级来决定是不是要实际落地这条消息，如果当前消息高于输出等级限制，那么我们会利用该日志消息封装一个更为详细的一个日志对象，然后利用日志器的格式化对象格式化成指定字符串，最后在完成实际落地！
同理对于，info、warning、error、fatal、unknown这几个接口的实现也是一样的；
2、 该基类还需要提供一个完成实际落地的接口log();来完成实际落地，该接口根据不同的日志器采用不同的实现，因此该接口必须是虚接口；
管理成员:
格式化对象；
vector数组，用来存放各种落地方向；
日志输出限制等级；
互斥锁；保证日志器是线程安全的；
日志器名称;(用于唯一标识一个日志器)

同步日志器

基于抽象基类所作的工作，同步日志器所做的工作就很简单，同步日志器只需要重写log（）接口完成实际落地就可以了:
同步日志器的落地方式也是比较简单的就是直接向落地方向中写入就好:
为此同步日志器的设计代码如下:

异步日志器

异步日志器呢就比较复杂一点了，为什么呢？
因为异步日志器与同步日志器不同，异步日志器不会完成日志消息的实际落地，异步日志器是将自己的日志消息落地到一个“缓冲区”中，由异步线程完成从缓冲区中取出数据来完成实际落地！

下面我们来具体聊一聊异步日志器的工作流程:
首先，我们的工作线程落地不在向实际方向落地而是向“缓冲区”中落地，由我们的异步线程来从缓冲区中取出数据来完成实际落地；
因此这是一个典型的生产者消费者模型，在这个过程中我们需要维护，生产者&生产者 生产者&消费者之间的互斥关系，因此我们需要一把锁 同时需要两个条件变量分别用来维护生产者消费者之间的同步关系，当缓冲区满了，我们需要阻塞生产者线程，让消费者线程来；当缓冲区为空了，我们需要阻塞消费者线程，让生产者来进行生产活动！
这些都没问题！可是在实际开发中，锁与锁的冲突无疑是比较严重的，因为这把锁每时每刻除了有生产者和生产者在竞争也有生产者和消费者在竞争，竞争是比较激烈的，这样的话就会导致整个异步日志器的工作效率比较低，为此为了减少锁的冲突，提高效率，我们可以采用双缓冲区的作法

双缓冲区的工作流程是这样的，工作线程呢现在将数据全部放进生产缓冲区中，而异步线程只从消费缓冲区中拿数据，只有当消费缓冲区中的数据没了的时候我们才交换两个缓冲区，这时候我们消费者才需要去申请锁，而在一般情况下，我们生产者和消费者都不是关心的同一个缓冲区，我们自然也就不必每次都去申请锁，这样就减少了生产者和消费者之间的锁冲突，提高了整体工作效率！
当然，如果在消费缓冲区为空了同时生产缓冲区也为空了，那么就没有交换的必要了，我们就阻塞异步线程；
如果生产缓冲区被打满了，那么我们也就可以阻塞生产者，让消费者继续消费一会！

 缓冲区实现

上面交代了异步日志器工作流程，最为异步日志器必不可少的一环，我们先来实现缓冲区；
该缓冲区采用面向字节流的设计思想，不需要设计成为一个个string类型的缓冲区，因为设计成string类型的话，异步线程在取的时候就只能取一个落地一个，会增加IO次数，降低IO效率；同时异步线程在取string字符串的时候，需要自己先定义一个string缓冲区在来取，这又是一次没必要拷贝！为此我们的缓冲区采用面向字节流的思想！用户可以自主决定一次性从缓冲区中读取多少字节的数据！
该缓冲区提供的功能:
write();用户只需要调用write接口就能向缓冲区中写入数据；
begin（）；返回可读位置的指针，注意这里并没有实现read()接口，如果实现该接口的话，那么上层在读取的时候必须先定义一个缓冲区来读取，这势必会造成一次不必要的拷贝！
AbleReadSize（）；可读数据长度；
AbleWriteSize()；可写数据长度;
moveRead();移动读指针；
moveWrite();移动写指针;
reset();将读写指针置0；（交换缓冲区之前，需要对消费缓冲区做的动作）
swap();//交换两个缓冲区;
管理的成员:
vector
读指针
写指针

具体实现 

//buffer.hpp
#pragma once
/*
异步缓冲区：
功能:暂时接收工作线程发送的日志信息提供接口:
write接口:外界向缓冲区插入数据
begin();//可写位置指针
AbleWriteSize();//可写空间
AbleReadSize();//可读空间
moveRead()/moveWrite();//读写指针移动
reset();//复位
swap();//交换
成员:
vector<char>
read_index;
write_index;
*/
#include <iostream>
#include <vector>
#include <cassert>
namespace MySpace
{
#define DEFAULT_BUFFER_SIZE 10 * 1024 * 1024      // 10M
#define DEFAULT_BUFFER_THRESHOLD 80 * 1024 * 1024 // 80M//阈值
#define DEFAULT_BUFFER_INCREMENT 10 * 1024 * 1024 // 10M//增量class Buffer{public:Buffer(size_t cap = DEFAULT_BUFFER_SIZE) : _q(cap) {}bool write(const char *str, int len){// 如果可写空间不够?//有两种作法:1、扩容；//2、由外部直接在插入执前做插入判断，如果实际插入的大小<=AbleWriteSize()那么就直接插入即可；如果大于了，那么由外部进行阻塞！//这里的话我们缓冲区提供的是扩容操作//但是实际会不会扩容完全由用户控制//如果用户做插入检查，那么就不会发生扩容//如果用户不做插入检查，那么就会发生扩容EableEnoughSpace(len);// 进行拷贝std::copy(str, str + len, _q.begin() + _write_index);// 更新write指针moveWrite(len);return true;}const char *begin(){return &_q[_read_index];}// 可写空间size_t AbleWriteSize(){return _q.size() - _write_index;}// 可读空间大小size_t AbleReadSize(){return _write_index - _read_index;}void swap(Buffer &bf){_q.swap(bf._q);std::swap(_write_index, bf._write_index);std::swap(_read_index, bf._read_index);}void reset(){_write_index = _read_index = 0;}void moveRead(size_t len){assert(len + _read_index <= _write_index);_read_index += len;}bool empty(){return _write_index == _read_index;}private:void moveWrite(size_t len){assert(_write_index + len <= _q.size());_write_index += len;}void EableEnoughSpace(int len){if (len > AbleWriteSize()){//扩容也是有讲究的//在没到达阈值之前快速扩；//达到阈值过后线性扩！size_t newSize = _q.size() < DEFAULT_BUFFER_THRESHOLD ? 2 * _q.size() : _q.size() + DEFAULT_BUFFER_INCREMENT;_q.resize(newSize);}}std::vector<char> _q;size_t _read_index = 0;size_t _write_index = 0;};} // namespace MySpace

异步工作器实现

异步工作器模块实际上就是双缓冲区与异步线程的整合；
工作线程通过与异步线程交互来完成异步日志器的工作输出;
异步工作器提供的功能:
push:工作线程通过该接口向缓冲区添加数据；
stop();工作线程可以通过调用该接口来停止异步工作器的工作;
管理成员:
双缓冲区;
互斥锁;
两个条件变量;
_stop;停止标志
回调函数(也就是实际处理逻辑，消费数据怎么处理，由外部决定)
异步工作线程

代码实现

//looper.hpp
#pragma once
#include "buffer.hpp"
/*
异步工作器模块:
功能:异步处理主线程的日志消息，完成日志消息的实际落地
提供接口:
stop();//停止异步工作器
push();//方便工作线程向异步工作器提供数据
成员:
1、双缓冲区(生&消
2、互斥锁(保护生产者&生产者 消费者&生产者)
3、双条件变量(双缓冲区都为空,则阻塞异步线程;若生产缓冲区不够了，阻塞生产者)
4、异步线程
5、停止标志
6、实际处理逻辑(具体如何实现交给外部来决定，实现解耦)
*/
#include <atomic>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <functional>
namespace MySpace
{using func_t = std::function<void(Buffer &)>;class AsyncLooper{public:AsyncLooper(const func_t &f, bool safe = true) : _work(f), _stop(false), _t(&AsyncLooper::threadRuning, this), _safe(safe){}~AsyncLooper(){stop();}void stop(){_stop = true;_conCond.notify_all();_t.join();}void push(const char *str, int len){if (_stop)return;{std::unique_lock<std::mutex> locker(_mux);// 唤醒条件:或者实际写入的长度小于可写入的长度// 安全模式下执行if (_safe){_proCond.wait(locker, [&]() -> bool{ return len <= _proBuf.AbleWriteSize(); });}// 非安全模式下直接插入，不考虑空间问题，少了会自动扩容_proBuf.write(str, len);}// 唤醒消费者,有数据来消费了_conCond.notify_all();}private:void threadRuning(){while (true){// 尝试交换if (_conBuf.empty()){std::unique_lock<std::mutex> locker(_mux);// 唤醒条件:生产者队列不为空或者_stop标志被置true// 阻塞条件:生产者队列为空并且_stop置false;_conCond.wait(locker, [&]() -> bool{ return _proBuf.empty() == false || _stop; });if (_stop && _proBuf.empty())break;// 生产者缓冲区有数据被唤醒_conBuf.reset();_conBuf.swap(_proBuf);}_proCond.notify_all();_work(_conBuf);}_proCond.notify_all();}bool _safe = true;Buffer _proBuf; // 生产缓冲区Buffer _conBuf; // 消费缓冲区std::mutex _mux;std::condition_variable _proCond; // 生产者条件队列std::condition_variable _conCond; // 消费者条件队列std::atomic<bool> _stop;          // 停止标志std::thread _t;                   // 异步线程func_t _work;                     // 实际处理逻辑};
} // nam;espace

在该异步工作器模块中，我们提供了两种模式，安全模式和非安全模式；
处于非安全模式下的生产者线程在向缓冲区插入数据的时候不会发生扩容；
而处于安全模式下的生产者线程在向缓冲区插入数据的时候不会发生扩容，因为会被阻塞！ 

建造者模式

 现在同步日志器与异步日志器都已经建立好了，但是每次使用之前都需要我们自己将日志器所需要的零件构造好，很是麻烦，为此我们可以采用兼着做模式来帮我们完成零件构造的过程;

首先抽象出一个抽象建造者:
该建造者可以帮我们建造任何零件;
同时该建造者还具有根据零件完成组装的功能，这个根据具体的建造者建有关系，因此我们需要提供一个组装接口，该接口是虚接口:

 日志器管理模块实现

上面的功能已经差不多将日志系统的大厦建立起来了，可是上面建立的日志器只能在当前作用域使用，要是在其它作用域使用的话，那么就需要我们来传参完成，使用起来非常不方便！
可不可以设计一种管理器，该管理器可以将所创建出来的日志器都管理起来，同时这个管理器是全局唯一的，哪里都可以使用，我们只需要通过向该管理器告知日志器名称就能返回给我们指定日志器；答案是可以的!
该日志器管理类:
1、管理已创建的日志器
2、可以同通过该管理器在全局任意地方根据日志器名称获取日志器
3、该管理器默认提供一个标准输出的同步日志器
4、该管理器为单例对象，全局只有一个管理器对象
提供接口:
getInstance();//获取日志管理器对象
addLogger();//添加日志器
isExists();//日志器是否存在
getLogger();//获取日志器
getRootLogger();//获取默认日志器
管理成员;
unordered_map<string ,shared_ptr> _loggers;
mutex保证日志管理器对象的线程安全
默认日志器对象 (同步标输出)

代码

//logger.hpp
#pragma once
/*
日志器模块或者说写入方式模块
日志器是直接暴露给用户的
功能:完成用户交给日志器的具体日志打印工作
设计思想:
为此站在用户的角度来说就是
我只要将日志消息传递给日志器，日志器就能帮助我们完成日志的输出
因此日志器要提供一些接口来供用户传入日志消息
而站在日志器的角度来说，我通过上诉接口获取到了用户的日志信息，日志器要做的工作就是
根据用户传进来的日志信息封装一个日志对象
然后利用格式化类对象格式化日志对象
然后再使用一个落地接口完成最终落地！

一个日志器的落地方向可能不止一种，为此我们需要一个容器来保存落地方向
日志器也需要知道如何格式化对象,为此他需要一个格式化对象
多线程情况下，有可能多个线程使用同一个日志器对同一个落地方向进行输出，会造成线程安全，需要一把锁
日治器也需要一个限制等级来维护日志器正对那些等级的日志进行实际落地，那些日志不进行输出;
日志器也需要一个名字来标识唯一日志器

如果具体细分的话，日志器分为:同步日志器、异步日志器
为此为了方便管理日志器，可以采用继承的设计层次
*/
#include "util.hpp"
#include "level.hpp"
#include "format.hpp"
#include "sink.hpp"
#include "looper.hpp"
#include <mutex>
#include <stdarg.h>
#include <unordered_map>
namespace MySpace
{
    // 先抽象出一个基类日志器
    class Logger
    {
    public:
        virtual ~Logger() {}
        enum class LoggerType
        {
            LOGGER_SYNC, // 同步日志器
            LOGGER_ASYNC // 异步日志器
        };

        // 提供日志器基本功能
    public:
        Logger(const MySpace::Formater& fmt, const std::vector<std::shared_ptr<MySpace::Sink>>& sinks, const std::string name,
            MySpace::LogLevel lev = LogLevel::DEBUG, LoggerType type = LoggerType::LOGGER_SYNC)
            : _fmter(fmt), _sinks(sinks), _levelLimits(lev), _mux(), _loggerName(name)
        {
            if (_sinks.empty())
                _sinks.push_back(std::make_shared<StdoutSink>());
        }
        const std::string& name()
        {
            return _loggerName;
        }
        // 站在用户的角度，是我只要想给接口提供日志信息就能完成debug等级的输出
        void debug(const std::string& fileName, size_t line, const char* fmat, ...)
        {
            // 站在日志器的角度来说，我收到了用户的日志信息，我需要将其加工成日志对象，然后格式化，然后完成实际落地
            // 0、先判断是否大于>=当前限制等级
            // 1、提取出日志消息主体;
            // 2、构造日志对象
            // 3、格式化
            va_list ap;
            va_start(ap, fmat);
            std::string str;
            // 完成0~3的工作
            if (!forwardRoll(fileName, line, LogLevel::DEBUG, str, fmat, ap))
            {
                va_end(ap);
                return;
            }
            va_end(ap);
            // 4、实际落地
            log(str);
        }
        void info(const std::string& fileName, size_t line, const char* fmat, ...)
        {

            va_list ap;
            va_start(ap, fmat);
            std::string str;
            // 完成0~3的工作
            if (!forwardRoll(fileName, line, LogLevel::INFO, str, fmat, ap))
            {
                va_end(ap);
                return;
            }
            va_end(ap);
            // 4、实际落地
            log(str);
        }
        void warning(const std::string& fileName, size_t line, const char* fmat, ...)
        {
            va_list ap;
            va_start(ap, fmat);
            std::string str;
            // 完成0~3的工作
            if (!forwardRoll(fileName, line, LogLevel::WARNING, str, fmat, ap))
            {
                va_end(ap);
                return;
            }
            va_end(ap);
            // 4、实际落地
            log(str);
        }
        void error(const std::string& fileName, size_t line, const char* fmat, ...)
        {
            va_list ap;
            va_start(ap, fmat);
            std::string str;
            // 完成0~3的工作
            if (!forwardRoll(fileName, line, LogLevel::Err, str, fmat, ap))
            {
                va_end(ap);
                return;
            }
            va_end(ap);
            // 4、实际落地
            log(str);
        }
        void fatal(const std::string& fileName, size_t line, const char* fmat, ...)
        {
            va_list ap;
            va_start(ap, fmat);
            std::string str;
            // 完成0~3的工作
            if (!forwardRoll(fileName, line, LogLevel::FATAL, str, fmat, ap))
            {
                va_end(ap);
                return;
            }
            va_end(ap);
            // 4、实际落地
            log(str);
        }
        void unknown(const std::string& fileName, size_t line, const char* fmat, ...)
        {
            va_list ap;
            va_start(ap, fmat);
            std::string str;
            // 完成0~3的工作
            if (!forwardRoll(fileName, line, LogLevel::UNKNOWN, str, fmat, ap))
            {
                va_end(ap);
                return;
            }
            va_end(ap);
            // 4、实际落地
            log(str);
        }

    private:
        bool forwardRoll(const std::string& fileName, size_t line, LogLevel lev, std::string& outBuffer, const char* fmat, va_list& ap)
        {
            if (lev < _levelLimits)
                return false;
            // 提取有效载荷消息
            char buffer[4096];
            vsnprintf(buffer, sizeof(buffer), fmat, ap);
            // 构建日志对象
            LogMes mes(fileName, line, lev, _loggerName, buffer);
            // 格式化
            outBuffer = _fmter.format(mes);
            return true;
        }

    protected:
        // 完成实际落地
        // 根据不同类型日志器完成不同的落地操作
        virtual void log(const std::string& str) = 0;
        MySpace::Formater _fmter;                           // 用来记录当前日志器的格式化格式
        std::vector<std::shared_ptr<MySpace::Sink>> _sinks; // 记录实际落地方向
        std::mutex _mux;                                    // 保护日志器的线程安全
        MySpace::LogLevel _levelLimits;                     // 日志限制输出等级
        std::string _loggerName;                            // 日志器名称
        LoggerType _type;
    };

    // 具体派生出一个同步日志器
    class SyncLogger : public Logger
    {
    public:
        SyncLogger(const MySpace::Formater& fmt, const std::vector<std::shared_ptr<MySpace::Sink>>& sinks, const std::string name,
            MySpace::LogLevel lev = LogLevel::DEBUG) : Logger(fmt, sinks, name, lev, LoggerType::LOGGER_SYNC) {}
        virtual void log(const std::string& str) override
        {
            std::lock_guard<std::mutex> locker(_mux);
            for (auto& e : _sinks)
                e->outLog(str.c_str(), str.length());
        }
    };
    // 具体派生出一个异步日器
    class AsyncLogger : public Logger
    {
    public:
        AsyncLogger(const MySpace::Formater& fmt, const std::vector<std::shared_ptr<MySpace::Sink>>& sinks, const std::string name,
            MySpace::LogLevel lev = LogLevel::DEBUG, bool safe = true) : Logger(fmt, sinks, name, lev, LoggerType::LOGGER_SYNC), _looper(std::bind(&AsyncLogger::realLog, this, std::placeholders::_1), safe)
        {
        }
        virtual void log(const std::string& str) override
        {
            _looper.push(str.c_str(), str.size());
        }
    private:
        void realLog(Buffer& bf)
        {
            for (auto& e : _sinks)
                e->outLog(bf.begin(), bf.AbleReadSize());
            bf.moveRead(bf.AbleReadSize());
        }
        MySpace::AsyncLooper _looper;
    };

    // 创建日志器所需要的零件
    class Builder
    {
    public:
        virtual ~Builder() {}
        void buildLoggerName(const std::string name)
        {
            _loggerName = name;
        }
        void buildLoggerType(Logger::LoggerType type = Logger::LoggerType::LOGGER_SYNC)
        {
            _type = type;
        }
        void buildFormater(const std::string& fmt = "")
        {
            if (fmt == "")
                _fmt = Formater();
            else
                _fmt = Formater(fmt);
        }
        void buildLevelLimits(LogLevel lev = LogLevel::DEBUG)
        {
            _levelLimits = lev;
        }
        // 建造异步建造器时时所使用
        void EnableSafe(bool flag)
        {
            _safe = flag;
        }
        template <class T, class... Args>
        void buildSink(Args... args)
        {
            _sinks.push_back(SinkFactory::createSink<T>(args...));
        }
        // 根据零件组合一个具体对象
        virtual std::shared_ptr<Logger> build() = 0;

    protected:
        bool _safe = true; // 异步日志器建造需要(默认安全)
        std::string _loggerName;
        Logger::LoggerType _type;
        Formater _fmt;
        MySpace::LogLevel _levelLimits;
        std::vector<std::shared_ptr<MySpace::Sink>> _sinks;
    };

    // 局部日志器建造
    class LocalLoggerBuilder : public Builder
    {
    public:
        virtual std::shared_ptr<Logger> build() override
        {
            std::shared_ptr<  std::vector<std::shared_ptr<MySpace::Sink>>> sp(&_sinks, [](std::vector < std::shared_ptr<MySpace::Sink>>*ptr)->void {
                ptr->clear();
                });
            if (_type == Logger::LoggerType::LOGGER_SYNC)
                return std::make_shared<SyncLogger>(_fmt, _sinks, _loggerName, _levelLimits);
            else
                return std::make_shared<AsyncLogger>(_fmt, _sinks, _loggerName, _levelLimits, _safe);
        }
    };
    /*
   创建一个日志器管理类:
   该类提供的作用:
   1、管理已创建的日志器
   2、可以同通过该管理器在全局任意地方根据日志器名称获取日志器
   3、该管理器默认提供一个标标准输出的日志器
   4、该管理器为单例对象，全局只有一个管理器对象
   提供接口:
       getInstance();//获取日志管理器对象
       addLogger();//添加日志器
       isExists();//日志器是否存在
       getLogger();//获取日志器
       getRootLogger();//获取默认日志器
   管理成员;
   unordered_map<string ,shared_ptr<Logger>> _loggers;
   mutex保证日志管理器对象的线程安全
   默认日志器对象 (同步标输出)
   */
    class loggerManager
    {
    public:
        static loggerManager& getInstance()
        {
            static loggerManager lo;
            return lo;
        }
        void addLogger(std::shared_ptr<Logger>& ptr)
        {
            if (isExists(ptr->name()))
                return;
            _loggers[ptr->name()] = ptr;
        }
        bool isExists(const std::string& name)
        {
            auto it = _loggers.find(name);
            if (it == _loggers.end())
                return false;
            return true;
        }
        std::shared_ptr<Logger> getLogger(const std::string& name)
        {
            if (isExists(name))
                return _loggers[name];
            return nullptr;
        }
        std::shared_ptr<Logger> getRootLogger()
        {
            return _root;
        }

    private:
        loggerManager()
        {
            LocalLoggerBuilder lo;
            lo.buildFormater();
            lo.buildLevelLimits();
            lo.buildLoggerName("root");
            lo.buildLoggerType();
            lo.buildSink<StdoutSink>();
            _root = lo.build();
            std::string name("root");
            _loggers[name] = _root;
        }
        loggerManager(const loggerManager&) = delete;
        loggerManager(loggerManager&&) = delete;
        std::unordered_map<std::string, std::shared_ptr<Logger>> _loggers;
        std::mutex _mux;
        std::shared_ptr<Logger> _root; // 默认日志器
    };
    // 全局日志器建造者//改日志器建造者是配合日志器管理对象来使用的
    // 与局部日志器建造者的唯一区别就是多了一步将构建出来的日志器添加进日志器管理对象的步骤
    // 省去了用户需要手动添加的过程
    class GobalLoggerBuilder : public Builder
    {
    public:
        virtual std::shared_ptr<Logger> build() override
        {
            std::shared_ptr<  std::vector<std::shared_ptr<MySpace::Sink>>> sp(&_sinks, [](std::vector < std::shared_ptr<MySpace::Sink>>* ptr)->void {
                ptr->clear();
                });
            std::shared_ptr<Logger> it(nullptr);
            if (_type == Logger::LoggerType::LOGGER_SYNC)
                it = std::make_shared<SyncLogger>(_fmt, _sinks, _loggerName, _levelLimits);
            else
                it = std::make_shared<AsyncLogger>(_fmt, _sinks, _loggerName, _levelLimits, _safe);
            //_sinks.clear();
            loggerManager::getInstance().addLogger(it);
            return it;
        }
    };
}