logger.h

Go to the documentation of this file.

 
#pragma once
 
#include <thread>
#include <variant>
#include <functional>
#include <promeki/core/namespace.h>
#include <promeki/core/string.h>
#include <promeki/core/stringlist.h>
#include <promeki/core/queue.h>
#include <promeki/core/map.h>
#include <promeki/core/mutex.h>
#include <promeki/core/atomic.h>
#include <promeki/core/promise.h>
#include <promeki/core/datetime.h>
#include <promeki/core/timestamp.h>
 
PROMEKI_NAMESPACE_BEGIN
 
static consteval const char *sourceFileName(const char *path) {
        const char *ret = path;
        for(const char *p = path; *p; ++p) {
                if(*p == '/' || *p == '\\') ret = p + 1;
        }
        return ret;
}
 
#ifdef __FILE_NAME__
#define PROMEKI_SOURCE_FILE __FILE_NAME__
#else
#define PROMEKI_SOURCE_FILE promeki::sourceFileName(__FILE__)
#endif
 
// Variadic macros for logging at various levels
 
#define PROMEKI_DEBUG(name) \
        namespace { \
                [[maybe_unused]] static const char *_promeki_debug_name = PROMEKI_STRINGIFY(name); \
                [[maybe_unused]] static bool _promeki_debug_enabled = \
                promekiRegisterDebug(&_promeki_debug_enabled, PROMEKI_STRINGIFY(name), PROMEKI_SOURCE_FILE, __LINE__); \
        }
 
#define promekiLogImpl(_plevel, format, ...) \
        do { if(!(_plevel) || (_plevel) >= Logger::defaultLogger().level()) \
                Logger::defaultLogger().log(_plevel, PROMEKI_SOURCE_FILE, __LINE__, String::sprintf(format, ##__VA_ARGS__)); \
        } while(0)
#define promekiLog(level, format, ...) promekiLogImpl(level, format, ##__VA_ARGS__)
#define promekiLogSync() Logger::defaultLogger().sync()
#define promekiLogStackTrace(_plevel) \
        do { if(!(_plevel) || (_plevel) >= Logger::defaultLogger().level()) \
                Logger::defaultLogger().log(_plevel, PROMEKI_SOURCE_FILE, __LINE__, promekiStackTrace()); \
        } while(0)
 
#ifdef PROMEKI_DEBUG_ENABLE
#define promekiDebug(format, ...) if(_promeki_debug_enabled) { promekiLog(Logger::LogLevel::Debug, format, ##__VA_ARGS__); }
#else
#define promekiDebug(format, ...)
#endif
 
#define promekiInfo(format, ...)  promekiLog(Logger::LogLevel::Info,  format, ##__VA_ARGS__)
#define promekiWarn(format, ...)  promekiLog(Logger::LogLevel::Warn,  format, ##__VA_ARGS__)
#define promekiErr(format, ...)   promekiLog(Logger::LogLevel::Err,   format, ##__VA_ARGS__)
 
bool promekiRegisterDebug(bool *enabler, const char *name, const char *file, int line);
 
#define PROMEKI_BENCHMARK_BEGIN(name) \
        TimeStamp _promeki_debug_timestamp_##name; \
        if(_promeki_debug_enabled) { _promeki_debug_timestamp_##name = TimeStamp::now(); }
 
#define PROMEKI_BENCHMARK_END(name) \
        if(_promeki_debug_enabled) { \
                Logger::defaultLogger().log(Logger::LogLevel::Debug, __FILE__, __LINE__, String::sprintf("[%s] %s took %.9lf sec", \
                        _promeki_debug_name, PROMEKI_STRINGIFY(name), _promeki_debug_timestamp_##name.elapsedSeconds())); \
        }
 
class Logger {
        public:
                enum LogLevel {
                        Force   = 0,      
                        Debug   = 1,      
                        Info    = 2,      
                        Warn    = 3,      
                        Err     = 4       
                };
 
                struct LogEntry {
                        DateTime        ts;
                        LogLevel        level;
                        const char *    file;
                        int             line;
                        uint64_t        threadId;
                        String          msg;
                };
 
                struct LogFormat {
                        const LogEntry  *entry;
                        const String    *threadName;
                };
 
                using LogFormatter = std::function<String(const LogFormat &fmt)>;
 
                static Logger &defaultLogger();
 
                static char levelToChar(LogLevel level);
 
                static void setThreadName(const String &name);
 
                static LogFormatter defaultFileFormatter();
 
                static LogFormatter defaultConsoleFormatter();
 
                Logger();
 
                ~Logger() {
                        _queue.emplace(CmdTerminate{});
                        _thread.join();
                }
 
                int level() const {
                        return _level.value();
                }
 
                void log(LogLevel loglevel, const char *file, int line, const String &msg);
 
                void log(LogLevel loglevel, const char *file, int line, const StringList &lines);
 
                void setLogFile(const String &filename) {
                        _queue.emplace(CmdSetFile{filename});
                }
 
                void setLogLevel(LogLevel level) {
                        _level.setValue(level);
                        log(Force, "LOGGER", 0, String::sprintf("Logging Level Changed to %d", level));
                        return;
                }
 
                void setConsoleLoggingEnabled(bool val) {
                        _consoleLogging.setValue(val);
                        return;
                }
 
                LogFormatter fileFormatter() const {
                        Mutex::Locker lock(_formatterMutex);
                        return _fileFormatter;
                }
 
                LogFormatter consoleFormatter() const {
                        Mutex::Locker lock(_formatterMutex);
                        return _consoleFormatter;
                }
 
                void setFileFormatter(LogFormatter formatter) {
                        {
                                Mutex::Locker lock(_formatterMutex);
                                _fileFormatter = formatter ? formatter : defaultFileFormatter();
                        }
                        _queue.emplace(CmdSetFormatter{std::move(formatter), false});
                }
 
                void setConsoleFormatter(LogFormatter formatter) {
                        {
                                Mutex::Locker lock(_formatterMutex);
                                _consoleFormatter = formatter ? formatter : defaultConsoleFormatter();
                        }
                        _queue.emplace(CmdSetFormatter{std::move(formatter), true});
                }
 
                Error sync(unsigned int timeoutMs = 0) {
                        auto p = std::make_shared<Promise<void>>();
                        Future<void> f = p->future();
                        _queue.emplace(CmdSync{std::move(p)});
                        if(timeoutMs == 0) {
                                f.waitForFinished();
                                return Error::Ok;
                        }
                        return f.waitForFinished(timeoutMs);
                }
 
        private:
 
                struct CmdSetThreadName {
                        uint64_t        threadId;
                        String          name;
                };
 
                struct CmdSetFile {
                        String          filename;
                };
 
                struct CmdSetFormatter {
                        LogFormatter    formatter;
                        bool            console;
                };
 
                struct CmdSync {
                        std::shared_ptr<Promise<void>> promise;
                };
 
                struct CmdTerminate {};
 
                using Command = std::variant<LogEntry, CmdSetThreadName, CmdSetFile, CmdSetFormatter, CmdSync, CmdTerminate>;
 
                std::thread             _thread;
                Atomic<int>             _level;
                Atomic<bool>            _consoleLogging;
                Queue<Command>          _queue;
                mutable Mutex           _formatterMutex;
                LogFormatter            _fileFormatter;
                LogFormatter            _consoleFormatter;
                Map<uint64_t, String>   _threadNames;
 
                void worker();
                void writeLog(const LogEntry &cmd, class FileIODevice *logFile);
                class FileIODevice *openLogFile(const String &filename, class FileIODevice *existing);
 
};
 
PROMEKI_NAMESPACE_END