logger.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_LOGGING_LOGGER_HPP__
#define NEFORCE_CORE_LOGGING_LOGGER_HPP__

 
#include "NeForce/core/async/condition_variable.hpp"
#include "NeForce/core/container/queue.hpp"
#include "NeForce/core/functional/function.hpp"
#include "NeForce/core/memory/shared_ptr.hpp"
#include "NeForce/logging/log_sink.hpp"
NEFORCE_BEGIN_NAMESPACE__


class NEFORCE_API logger {
private:
    log_level level_;    
    atomic<bool> async_; 
 
    vector<shared_ptr<log_sink>> sinks_; 
    mutex sinks_mutex_;                  
 
    queue<log_event> queue_; 
    mutex queue_mutex_;      
    condition_variable cv_;  
 
    thread worker_;        
    atomic<bool> running_; 
 
    atomic<bool> flush_requested_{false}; 
    mutex flush_mutex_;                   
    condition_variable flush_cv_;         
 
    function<bool(const log_event&)> filter_; 
    mutex filter_mutex_;                      
 
    unordered_map<string, string> context_; 
    mutex context_mutex_;                   

    void enqueue(log_event&& event);

    void enqueue(const log_event& event);

    void start_worker();

    void stop_worker();

    void worker_loop();

    explicit logger(log_level level = log_level::INFO, bool async = false);
 
public:
    static logger& instance() {
        static logger log;
        return log;
    }
 
    logger(const logger&) = delete;
    logger& operator=(const logger&) = delete;
    logger(logger&&) = delete;
    logger& operator=(logger&&) = delete;

    ~logger();

    void add_sink(shared_ptr<log_sink> sink);

    void set_level(log_level level);

    void set_filter(function<bool(const log_event&)> filter);

    void add_context(const string& key, string value);

    void remove_context(const string& key);

    void clear_context();

    void enable_async(bool async);

    void log(log_level level, string msg, string file, string func, int line);

    void trace(string msg, string file, string func, int line) {
        log(log_level::TRACE, move(msg), move(file), move(func), line);
    }

    void debug(string msg, string file, string func, int line) {
        log(log_level::DEBUG, move(msg), move(file), move(func), line);
    }

    void info(string msg, string file, string func, int line) {
        log(log_level::INFO, move(msg), move(file), move(func), line);
    }

    void warn(string msg, string file, string func, int line) {
        log(log_level::WARN, move(msg), move(file), move(func), line);
    }

    void error(string msg, string file, string func, int line) {
        log(log_level::ERROR, move(msg), move(file), move(func), line);
    }

    void fatal(string msg, string file, string func, int line) {
        log(log_level::FATAL, move(msg), move(file), move(func), line);
    }

    void flush();
};
 

#define NEFORCE_LOG_TRACE(msg) _NEFORCE logger::instance().trace(msg, __FILE__, __func__, __LINE__)

#define NEFORCE_LOG_DEBUG(msg) _NEFORCE logger::instance().debug(msg, __FILE__, __func__, __LINE__)

#define NEFORCE_LOG_INFO(msg) _NEFORCE logger::instance().info(msg, __FILE__, __func__, __LINE__)

#define NEFORCE_LOG_WARN(msg) _NEFORCE logger::instance().warn(msg, __FILE__, __func__, __LINE__)

#define NEFORCE_LOG_ERROR(msg) _NEFORCE logger::instance().error(msg, __FILE__, __func__, __LINE__)

#define NEFORCE_LOG_FATAL(msg) _NEFORCE logger::instance().fatal(msg, __FILE__, __func__, __LINE__)
 

#define NEFORCE_LOGF_TRACE(msg, ...) \
    _NEFORCE logger::instance().trace(_NEFORCE format(msg, __VA_ARGS__), __FILE__, __func__, __LINE__)

#define NEFORCE_LOGF_DEBUG(msg, ...) \
    _NEFORCE logger::instance().debug(_NEFORCE format(msg, __VA_ARGS__), __FILE__, __func__, __LINE__)

#define NEFORCE_LOGF_INFO(msg, ...) \
    _NEFORCE logger::instance().info(_NEFORCE format(msg, __VA_ARGS__), __FILE__, __func__, __LINE__)

#define NEFORCE_LOGF_WARN(msg, ...) \
    _NEFORCE logger::instance().warn(_NEFORCE format(msg, __VA_ARGS__), __FILE__, __func__, __LINE__)

#define NEFORCE_LOGF_ERROR(msg, ...) \
    _NEFORCE logger::instance().error(_NEFORCE format(msg, __VA_ARGS__), __FILE__, __func__, __LINE__)

#define NEFORCE_LOGF_FATAL(msg, ...) \
    _NEFORCE logger::instance().fatal(_NEFORCE format(msg, __VA_ARGS__), __FILE__, __func__, __LINE__)
 // Logging
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_LOGGING_LOGGER_HPP__