logger.hpp

Go to the documentation of this file.

#pragma once
 
#include "ft_format.hpp"
 
#include <iostream>
#include <fstream>
#include <sstream>
#include <ctime>
#include <iomanip>
#include <filesystem>
#include <memory>
#include <mutex>
 
#define LOG_CRITICAL(...) logger << Logger::Level::CRITICAL << __VA_ARGS__ << std::endl
#define LOG_ERROR(...) logger << Logger::Level::ERROR << __VA_ARGS__ << std::endl
#define LOG_WARNING(...) logger << Logger::Level::WARNING << __VA_ARGS__ << std::endl
#define LOG_INFO(...) logger << Logger::Level::INFO << __VA_ARGS__ << std::endl
#define LOG_DEBUG(...) logger << Logger::Level::DEBUG << __VA_ARGS__ << std::endl
#define LOG_TRACE(...) logger << Logger::Level::TRACE << __VA_ARGS__ << std::endl
 
#define LOG_CRITICAL_FMT(fmt, ...) logger << Logger::Level::CRITICAL << ft_format(fmt, __VA_ARGS__) << std::endl
#define LOG_ERROR_FMT(fmt, ...) logger << Logger::Level::ERROR << ft_format(fmt, __VA_ARGS__) << std::endl
#define LOG_WARNING_FMT(fmt, ...) logger << Logger::Level::WARNING << ft_format(fmt, __VA_ARGS__) << std::endl
#define LOG_INFO_FMT(fmt, ...) logger << Logger::Level::INFO << ft_format(fmt, __VA_ARGS__) << std::endl
#define LOG_DEBUG_FMT(fmt, ...) logger << Logger::Level::DEBUG << ft_format(fmt, __VA_ARGS__) << std::endl
#define LOG_TRACE_FMT(fmt, ...) logger << Logger::Level::TRACE << ft_format(fmt, __VA_ARGS__) << std::endl
 
// #define LOG_CRITICAL_FMT(fmt, ...) logger << Logger::Level::CRITICAL << fmt << std::endl, __VA_ARGS__
 
class FileOutput: public std::ofstream
{
 
public:
 
    FileOutput(const std::filesystem::path & path);
 
    FileOutput(FileOutput &&other);
 
    ~FileOutput();
 
};
 
class Logger
{
 
public:
 
    enum Level
    {
        CRITICAL = 0,
        ERROR = 1,
        WARNING = 2,
        INFO = 3,
        DEBUG = 4,
        TRACE = 5,
        MAX = 6
    };
 
 
    Logger();
 
    Logger(const std::filesystem::path & path);
 
    void configure(const std::filesystem::path & path);
 
    void setLevel(Level level);
 
    Level level() const;
 
    void setTimestamp(bool enabled);
 
    Logger & operator<<(Level level);
 
    Logger & operator<<(std::ostream & (*manipulator)(std::ostream &));
 
    template <typename T>
    Logger & operator<<(T const & arg)
    {
        m_current_msg << arg;
        return *this;
    }
 
private:
 
    bool m_file_initialized = false;
 
    std::stringstream m_current_msg;
 
    std::unique_ptr<FileOutput> m_log_files[static_cast<int>(Level::MAX)];
 
    Level m_min_console_level = Level::TRACE;
 
    Level m_next_msg_level = Level::INFO;
 
    bool m_timestamp_enabled = true;
 
    std::mutex m_mutex;
 
    inline static std::string const m_level_to_string[static_cast<uint32_t>(MAX)] =
    {
        "[CRITICAL]:",
        "[ERROR]   :",
        "[WARNING] :",
        "[INFO]    :",
        "[DEBUG]   :",
        "[TRACE]   :"
    };
 
    inline static std::string const m_level_to_color[static_cast<uint32_t>(MAX)] =
    {
        "\033[33;41;1m",
        "\033[31m",
        "\033[33m",
        "\033[32m",
        "\033[34m",
        "\033[35m"
    };
 
    void _flush();
 
    FileOutput & _logFile(Level level) const;
 
    void _writeToConsole(std::string const & message);
 
    void _writeToFile(std::string const & message);
 
    std::string _levelHeader(Level level, bool color = true);
 
    std::string _timestamp();
 
};
 
extern Logger logger;