logger.h

Go to the documentation of this file.

 
#ifndef MB_LOGGER_H
#define MB_LOGGER_H
 
#include <iostream>
#include <nlohmann/json.hpp>
#include <spdlog/spdlog.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <memory>
 
#include "log_database.h"
#include "../../utils/utils.h"
 
namespace mb {
    using json = nlohmann::json;
 
    // Forward declaration
    class LogDatabase;
 
    typedef enum class LogLevel : uint8_t {
        TRACE = 0, 
        DEBUG, 
        INFO, 
        WARN, 
        CRITICAL 
    } LogLevel;
 
    class Logger {
        std::unique_ptr<LogDatabase> m_logsDb;
 
    public:
        Logger();
        ~Logger() { std::cout << "Logger Des()" << std::endl; }
 
        inline static std::atomic<bool> isDbInitialized = false;
 
        static void setLogLevel(const LogLevel &level = LogLevel::INFO);
 
        [[nodiscard]] LogDatabase &logsDb() const;
 
        static void initDb(const std::string &data_dir = "");
 
        // Logging methods with structured format:
        // - origin: Component/system origin (System, Auth, Database, Entity, EntitySchema, etc.)
        // - message: Short message (e.g., "Auth Failed", "Database Connected")
        // - details: Long description of the message
        // - data: Optional JSON object/array with additional data
        static void trace(const std::string &origin,
                          const std::string &message,
                          const std::string &details = "",
                          const json &data = json::object());
 
        static void info(const std::string &origin,
                         const std::string &message,
                         const std::string &details = "",
                         const json &data = json::object());
 
        static void debug(const std::string &origin,
                          const std::string &message,
                          const std::string &details = "",
                          const json &data = json::object());
 
        static void warn(const std::string &origin,
                         const std::string &message,
                         const std::string &details = "",
                         const json &data = json::object());
 
        static void critical(const std::string &origin,
                             const std::string &message,
                             const std::string &details = "",
                             const json &data = json::object());
 
    private:
        template<typename... Args>
        static void trace_spdlog(fmt::format_string<Args...> msg, Args &&... args) {
            spdlog::trace(msg, std::forward<Args>(args)...);
        }
 
        template<typename... Args>
        static void info_spdlog(fmt::format_string<Args...> msg, Args &&... args) {
            spdlog::info(msg, std::forward<Args>(args)...);
        }
 
        template<typename... Args>
        static void debug_spdlog(fmt::format_string<Args...> msg, Args &&... args) {
            spdlog::debug(msg, std::forward<Args>(args)...);
        }
 
        template<typename... Args>
        static void warn_spdlog(fmt::format_string<Args...> msg, Args &&... args) {
            spdlog::warn(msg, std::forward<Args>(args)...);
        }
 
        template<typename... Args>
        static void critical_spdlog(fmt::format_string<Args...> msg, Args &&... args) {
            spdlog::critical(msg, std::forward<Args>(args)...);
        }
 
        static void logToDatabase(const std::string &level,
                                  const std::string &origin,
                                  const std::string &message,
                                  const std::string &details,
                                  const json &data = json::object());
    };
 
    namespace logEntry {
        // System logging
        inline void trace(const std::string &origin,
                          const std::string &message,
                          const std::string &details = "",
                          const json &data = json::object()) {
            Logger::trace(origin, message, details, data);
        }
 
        inline void info(const std::string &origin,
                         const std::string &message,
                         const std::string &details = "",
                         const json &data = json::object()) {
            Logger::info(origin, message, details, data);
        }
 
        inline void debug(const std::string &origin,
                          const std::string &message,
                          const std::string &details = "",
                          const json &data = json::object()) {
            Logger::debug(origin, message, details, data);
        }
 
        inline void warn(const std::string &origin,
                         const std::string &message,
                         const std::string &details = "",
                         const json &data = json::object()) {
            Logger::warn(origin, message, details, data);
        }
 
        inline void critical(const std::string &origin,
                             const std::string &message,
                             const std::string &details = "",
                             const json &data = json::object()) {
            Logger::critical(origin, message, details, data);
        }
    }
 
    namespace LogOrigin {
        // System logging
        inline void trace(const std::string &message,
                          const std::string &details = "",
                          const json &data = json::object()) {
            Logger::trace("System", message, details, data);
        }
 
        inline void info(const std::string &message,
                         const std::string &details = "",
                         const json &data = json::object()) {
            Logger::info("System", message, details, data);
        }
 
        inline void debug(const std::string &message,
                          const std::string &details = "",
                          const json &data = json::object()) {
            Logger::debug("System", message, details, data);
        }
 
        inline void warn(const std::string &message,
                         const std::string &details = "",
                         const json &data = json::object()) {
            Logger::warn("System", message, details, data);
        }
 
        inline void critical(const std::string &message,
                             const std::string &details = "",
                             const json &data = json::object()) {
            Logger::critical("System", message, details, data);
        }
 
        // Auth logging
        inline void authTrace(const std::string &message,
                              const std::string &details = "",
                              const json &data = json::object()) {
            Logger::trace("Auth", message, details, data);
        }
 
        inline void authInfo(const std::string &message,
                             const std::string &details = "",
                             const json &data = json::object()) {
            Logger::info("Auth", message, details, data);
        }
 
        inline void authDebug(const std::string &message,
                              const std::string &details = "",
                              const json &data = json::object()) {
            Logger::debug("Auth", message, details, data);
        }
 
        inline void authWarn(const std::string &message,
                             const std::string &details = "",
                             const json &data = json::object()) {
            Logger::warn("Auth", message, details, data);
        }
 
        inline void authCritical(const std::string &message,
                                 const std::string &details = "",
                                 const json &data = json::object()) {
            Logger::critical("Auth", message, details, data);
        }
 
        // Database logging
        inline void dbTrace(const std::string &message,
                            const std::string &details = "",
                            const json &data = json::object()) {
            Logger::trace("Database", message, details, data);
        }
 
        inline void dbInfo(const std::string &message,
                           const std::string &details = "",
                           const json &data = json::object()) {
            Logger::info("Database", message, details, data);
        }
 
        inline void dbDebug(const std::string &message,
                            const std::string &details = "",
                            const json &data = json::object()) {
            Logger::debug("Database", message, details, data);
        }
 
        inline void dbWarn(const std::string &message,
                           const std::string &details = "",
                           const json &data = json::object()) {
            Logger::warn("Database", message, details, data);
        }
 
        inline void dbCritical(const std::string &message,
                               const std::string &details = "",
                               const json &data = json::object()) {
            Logger::critical("Database", message, details, data);
        }
 
        // Entity logging
        inline void entityTrace(const std::string &message,
                                const std::string &details = "",
                                const json &data = json::object()) {
            Logger::trace("Entity", message, details, data);
        }
 
        inline void entityInfo(const std::string &message,
                               const std::string &details = "",
                               const json &data = json::object()) {
            Logger::info("Entity", message, details, data);
        }
 
        inline void entityDebug(const std::string &message,
                                const std::string &details = "",
                                const json &data = json::object()) {
            Logger::debug("Entity", message, details, data);
        }
 
        inline void entityWarn(const std::string &message,
                               const std::string &details = "",
                               const json &data = json::object()) {
            Logger::warn("Entity", message, details, data);
        }
 
        inline void entityCritical(const std::string &message,
                                   const std::string &details = "",
                                   const json &data = json::object()) {
            Logger::critical("Entity", message, details, data);
        }
 
        // EntitySchema logging
        inline void entitySchemaTrace(const std::string &message,
                                      const std::string &details = "",
                                      const json &data = json::object()) {
            Logger::trace("EntitySchema", message, details, data);
        }
 
        inline void entitySchemaInfo(const std::string &message,
                                     const std::string &details = "",
                                     const json &data = json::object()) {
            Logger::info("EntitySchema", message, details, data);
        }
 
        inline void entitySchemaDebug(const std::string &message,
                                      const std::string &details = "",
                                      const json &data = json::object()) {
            Logger::debug("EntitySchema", message, details, data);
        }
 
        inline void entitySchemaWarn(const std::string &message,
                                     const std::string &details = "",
                                     const json &data = json::object()) {
            Logger::warn("EntitySchema", message, details, data);
        }
 
        inline void entitySchemaCritical(const std::string &message,
                                         const std::string &details = "",
                                         const json &data = json::object()) {
            Logger::critical("EntitySchema", message, details, data);
        }
    }
 
    class FuncLogger {
    public:
        explicit FuncLogger(std::string msg);
 
        ~FuncLogger();
 
    private:
        std::string m_msg;
    };
}
 
// Macro to automatically insert logger with function name
inline std::string getFile(const std::string &path) {
    const std::filesystem::path p = path;
    return p.filename().string();
}
 
#define MB_FUNC() std::format("{} - {}()", getFile(__FILE__), __FUNCTION__)
#define TRACE_FUNC(x) mb::FuncLogger _logger(x);
#define TRACE_MB_FUNC() try{ mb::FuncLogger _logger(MB_FUNC()); } catch(...){}
#define TRACE_CLASS_METHOD() mb::FuncLogger _logger(std::format("{} {}::{}()", getFile(__FILE__), "", __FUNCTION__));
#define TRACE_METHOD() mb::FuncLogger _logger(std::format("{} {}()", getFile(__FILE__), __FUNCTION__));
 
#endif // MB_LOGGER_H