logger.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <variant>
#include <functional>
#include <promeki/basicthread.h>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
#include <promeki/queue.h>
#include <promeki/deque.h>
#include <promeki/list.h>
#include <promeki/map.h>
#include <promeki/mutex.h>
#include <promeki/atomic.h>
#include <promeki/promise.h>
#include <promeki/datetime.h>
#include <promeki/gate.h>
#include <promeki/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) {                                                                                  \
                Logger::defaultLogger().log(Logger::LogLevel::Debug, PROMEKI_SOURCE_FILE, __LINE__,                    \
                                            String::sprintf(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__)
 
#define promekiInfoOnce(format, ...)                                                                                   \
        PROMEKI_ONCE { promekiInfo(format, ##__VA_ARGS__); }
 
#define promekiWarnOnce(format, ...)                                                                                   \
        PROMEKI_ONCE { promekiWarn(format, ##__VA_ARGS__); }
 
#define promekiErrOnce(format, ...)                                                                                    \
        PROMEKI_ONCE { promekiErr(format, ##__VA_ARGS__); }
 
#define promekiInfoThrottled(intervalMs, format, ...)                                                                  \
        PROMEKI_THROTTLED(intervalMs) { promekiInfo(format, ##__VA_ARGS__); }
 
#define promekiWarnThrottled(intervalMs, format, ...)                                                                  \
        PROMEKI_THROTTLED(intervalMs) { promekiWarn(format, ##__VA_ARGS__); }
 
#define promekiErrThrottled(intervalMs, format, ...)                                                                   \
        PROMEKI_THROTTLED(intervalMs) { promekiErr(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, PROMEKI_SOURCE_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 = Function<String(const LogFormat &fmt)>;
 
                using ListenerHandle = uint64_t;
 
                using LogListener = Function<void(const LogEntry &entry, const String &threadName)>;
 
                static constexpr size_t DefaultHistorySize = 1024;
 
                static Logger &defaultLogger();
 
                static char levelToChar(LogLevel level);
 
                static void setThreadName(const String &name);
 
                struct DebugChannel {
                                String name;            
                                String file;            
                                int    line = 0;        
                                bool   enabled = false; 
 
                                using List = ::promeki::List<DebugChannel>;
                };
 
                static DebugChannel::List debugChannels();
 
                static bool setDebugChannel(const String &name, bool enabled);
 
                static LogFormatter defaultFileFormatter();
 
                static LogFormatter defaultConsoleFormatter();
 
                Logger();
 
                ~Logger();
 
                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) {
                        if (_terminating.value()) return;
                        _queue.emplace(CmdSetFile{filename});
                }
 
                void setLogLevel(LogLevel level) {
                        _level.setValue(level);
                        log(Force, "LOGGER", 0, String::sprintf("Logging Level Changed to %d", level));
                        return;
                }
 
                bool consoleLoggingEnabled() const { return _consoleLogging.value(); }
 
                void setConsoleLoggingEnabled(bool val) {
                        _consoleLogging.setValue(val);
                        return;
                }
 
                bool consoleUseStderr() const { return _consoleUseStderr.value(); }
 
                void setConsoleUseStderr(bool val) {
                        _consoleUseStderr.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();
                        }
                        if (_terminating.value()) return;
                        _queue.emplace(CmdSetFormatter{std::move(formatter), false});
                }
 
                void setConsoleFormatter(LogFormatter formatter) {
                        {
                                Mutex::Locker lock(_formatterMutex);
                                _consoleFormatter = formatter ? formatter : defaultConsoleFormatter();
                        }
                        if (_terminating.value()) return;
                        _queue.emplace(CmdSetFormatter{std::move(formatter), true});
                }
 
                ListenerHandle installListener(LogListener listener, size_t replayCount = 0);
 
                void removeListener(ListenerHandle handle);
 
                void setHistorySize(size_t n) { _historySize.setValue(n); }
 
                size_t historySize() const { return _historySize.value(); }
 
                Error sync(unsigned int timeoutMs = 0) {
                        if (_terminating.value()) return Error::Ok;
                        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 CmdInstallListener {
                                LogListener                              listener;
                                size_t                                   replayCount;
                                std::shared_ptr<Promise<ListenerHandle>> promise;
                };
 
                struct CmdRemoveListener {
                                ListenerHandle                 handle;
                                std::shared_ptr<Promise<void>> promise;
                };
 
                struct CmdTerminate {};
 
                using Command = std::variant<LogEntry, CmdSetThreadName, CmdSetFile, CmdSetFormatter, CmdSync,
                                             CmdInstallListener, CmdRemoveListener, CmdTerminate>;
 
                struct ListenerEntry {
                                ListenerHandle handle;
                                LogListener    fn;
                };
 
                struct HistoryEntry {
                                LogEntry entry;
                                String   threadName;
                };
 
                BasicThread           _thread;
                Atomic<int>           _level;
                Atomic<bool>          _consoleLogging;
                Atomic<bool>          _consoleUseStderr;
                Atomic<bool>          _terminating{false};
                Atomic<size_t>        _historySize{DefaultHistorySize};
                Atomic<uint64_t>      _nextListenerHandle{0};
                Queue<Command>        _queue;
                mutable Mutex         _formatterMutex;
                LogFormatter          _fileFormatter;
                LogFormatter          _consoleFormatter;
                Map<uint64_t, String> _threadNames;
                List<ListenerEntry>   _listeners; 
                Deque<HistoryEntry>   _history;   
 
                void                worker();
                void                writeLog(const LogEntry &cmd, class FileIODevice *logFile);
                class FileIODevice *openLogFile(const String &filename, class FileIODevice *existing);
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE