conscience_log.h

Go to the documentation of this file.

#ifndef LOG_TRACE_ENABLED
#define LOG_TRACE_ENABLED
#endif
 
#ifndef LOG_DEBUG_ENABLED
#define LOG_DEBUG_ENABLED
#endif
 
#ifndef LOG_INFO_ENABLED
#define LOG_INFO_ENABLED
#endif
 
#ifndef CONSCIENCE_LOG_H
#define CONSCIENCE_LOG_H
 
#include "os.h"
#if CSC_OS_WINDOWS == 1
        // windows uses a most recent version of spdlog
#define CSC_LEVEL_NAME_TRACE spdlog::string_view_t("trace", 5)
#define CSC_LEVEL_NAME_DEBUG spdlog::string_view_t("debug", 5)
#define CSC_LEVEL_NAME_INFO spdlog::string_view_t("info", 4)
#define CSC_LEVEL_NAME_WARNING spdlog::string_view_t("warning", 7)
#define CSC_LEVEL_NAME_ERROR spdlog::string_view_t("error", 5)
#define CSC_LEVEL_NAME_CRITICAL spdlog::string_view_t("user", 4)
#define CSC_LEVEL_NAME_OFF spdlog::string_view_t("off", 3)
#define SPDLOG_LEVEL_NAMES                                                                  \
        {                                                                                       \
            CSC_LEVEL_NAME_TRACE, CSC_LEVEL_NAME_DEBUG, CSC_LEVEL_NAME_INFO,           \
                CSC_LEVEL_NAME_WARNING, CSC_LEVEL_NAME_ERROR, CSC_LEVEL_NAME_CRITICAL, \
                CSC_LEVEL_NAME_OFF                                                           \
        }
#endif
 
#include "Util/conscience_util.h"
#include "spdlog/spdlog.h"
#include <map>
#include <string>
#include <memory>
#include <mutex>
 
using std::string, std::map, std::mutex, std::unique_ptr, std::make_unique;
 
namespace conscience_utils::logging {
 
    ENUM(LogLevel,
        LogLevel_TRACE,
        LogLevel_DEBUG,
        LogLevel_INFO,
        LogLevel_WARN,
        LogLevel_ERROR,
        LogLevel_USER
    );
 
    class CscLoggingConfiguration {
    public:
        inline static const map<string, LogLevel> levelsByName = {
            {"TRACE", LogLevel_TRACE},
            {"DEBUG", LogLevel_DEBUG},
            {"INFO", LogLevel_INFO},
            {"WARN", LogLevel_WARN},
            {"ERROR", LogLevel_ERROR},
        };
        
        static CscLoggingConfiguration *getInstance();
 
        void setGlobalLoggerLevel(LogLevel level);
 
        void setLevelAll(LogLevel level);
 
        void setMainFileName(string fileName);
 
        const string getMainFileName();
 
        const string getLogLinePrefix();
 
    private:
        inline static CscLoggingConfiguration *instance = nullptr;
        CscLoggingConfiguration();
 
        string mainFileName;
        string logLinePrefix = "(°°) ";
    };
 
    class CscLogger {
    public:
        static void globalLog(LogLevel level, string message, bool hilight = false);
 
        void setLevel(LogLevel level);
        void log(LogLevel level, string message, bool hilight = false) const;
        void trace(string message, bool hilight = false) const;
        void debug(string message, bool hilight = false) const;
        void info(string message, bool hilight = false) const;
        void warn(string message, bool hilight = false) const;
        void error(string message, bool hilight = false) const;
        void user(string message, bool hilight = false) const;
 
        static unique_ptr<CscLogger> getForCategory(string category);
        static string getLogDirectory();   
        static string getMainLogFilePath();
        static void addLogFileOutput(LogLevel minLevel, const string &outPath);
 
        static std::shared_ptr<spdlog::logger> getGlobalLogger();
        static bool isLoggingReady() {
            return mainLogSink != NULL;
        }
        virtual ~CscLogger() = default;
        
        bool isLevelEnabled(LogLevel level) const;
        bool isTraceEnabled() const;
        bool isDebugEnabled() const;
        bool isInfoEnabled() const;
        bool isWarnEnabled() const;
        bool isErrorEnabled() const;
        bool isUserEnabled() const;
        
    private:
        CscLogger(std::shared_ptr<spdlog::logger> internalLogger);
        std::shared_ptr<spdlog::logger> internalLogger;
 
        inline static std::shared_ptr<spdlog::sinks::sink> mainLogSink = nullptr;
        inline static std::shared_ptr<spdlog::logger> globalLogger = nullptr;
        inline static mutex sinksInitMutex;
        inline static mutex globalLoggerInitMutex;
        inline static std::vector<spdlog::sink_ptr> sinks;
        static std::shared_ptr<spdlog::sinks::sink> getMainLogSink();
        static std::vector<spdlog::sink_ptr> getSinks();
        static void doLog(std::shared_ptr<spdlog::logger> logger, LogLevel level, string message, bool hilight);
    };
}
 
#endif
 
using namespace conscience_utils;
using namespace conscience_utils::logging;
 
#if defined LOG_INFO_ENABLED
#define LOG_INFO(message) CscLogger::globalLog(LogLevel_INFO, message, false);
#define LOG_HILIGHT(message) CscLogger::globalLog(LogLevel_INFO, message, true);
#else
#define LOG_INFO(message)
#define LOG_HILIGHT(message)
#endif
 
#if defined LOG_DEBUG_ENABLED
#define LOG_DEBUG(message) CscLogger::globalLog(LogLevel_DEBUG, message, false);
#else
#define LOG_DEBUG(message)
#endif
 
#if defined LOG_TRACE_ENABLED
#define LOG_TRACE(message) CscLogger::globalLog(LogLevel_TRACE, message, false);
#else
#define LOG_TRACE(message)
#endif
 
#define LOG_WARN(message) CscLogger::globalLog(LogLevel_WARN, message, false);
#define LOG_ERROR(message) CscLogger::globalLog(LogLevel_ERROR, message, false);
#define LOG_USER(message) CscLogger::globalLog(LogLevel_USER, message, false);
 
#define LOGGER_TRACE(message) if (logger->isTraceEnabled()) { logger->trace(message); }
#define LOGGER_DEBUG(message) if (logger->isDebugEnabled()) { logger->debug(message); }
#define LOGGER_INFO(message) if (logger->isInfoEnabled()) { logger->info(message); }
#define LOGGER_WARN(message) if (logger->isWarnEnabled()) { logger->warn(message); }
#define LOGGER_ERROR(message) if (logger->isErrorEnabled()) { logger->error(message); }
#define LOGGER_USER(message) if (logger->isUserEnabled()) { logger->user(message); }