merge(codex): add macro for setting minimum log level

Add log level control

Author: LimiNode

include/logit_cpp/logit/LogMacros.hpp

@@ -971,6 +971,17 @@
 #define LOGIT_SET_TIME_OFFSET(logger_index, offset_ms) \
     logit::Logger::get_instance().set_timestamp_offset(logger_index, offset_ms)
 
+/// \brief Sets minimal log level for a specific logger.
+/// \param logger_index Index of logger.
+/// \param level Minimum log level.
+#define LOGIT_SET_LOG_LEVEL_TO(logger_index, level) \
+    logit::Logger::get_instance().set_log_level(logger_index, level)
+
+/// \brief Sets minimal log level for all loggers.
+/// \param level Minimum log level.
+#define LOGIT_SET_LOG_LEVEL(level) \
+    logit::Logger::get_instance().set_log_level(level)
+
 /// \brief Checks if a logger is in single mode.
 /// \param logger_index Index of logger.
 /// \return True if in single mode, false otherwise.

include/logit_cpp/logit/Logger.hpp

@@ -94,6 +94,27 @@ namespace logit {
             }
         }
 
+        /// \brief Sets minimal log level for all loggers.
+        /// \param level Minimum log level.
+        void set_log_level(LogLevel level) {
+            if (m_shutdown) return;
+            std::lock_guard<std::mutex> lock(m_mutex);
+            for (auto& strategy : m_loggers) {
+                strategy.logger->set_log_level(level);
+            }
+        }
+
+        /// \brief Sets minimal log level for a specific logger.
+        /// \param logger_index Index of logger.
+        /// \param level Minimum log level.
+        void set_log_level(int logger_index, LogLevel level) {
+            if (m_shutdown) return;
+            std::lock_guard<std::mutex> lock(m_mutex);
+            if (logger_index >= 0 && logger_index < static_cast<int>(m_loggers.size())) {
+                m_loggers[logger_index].logger->set_log_level(level);
+            }
+        }
+
         /// \brief Checks whether a logger is in single mode.
         /// \param logger_index Index of logger.
         /// \return True if logger is in single mode, false otherwise.
@@ -118,12 +139,14 @@ namespace logit {
             if (record.logger_index >= 0 && record.logger_index < static_cast<int>(m_loggers.size())) {
                 const auto& strategy = m_loggers[record.logger_index];
                 if (!strategy.enabled) return;
+                if (static_cast<int>(record.log_level) < static_cast<int>(strategy.logger->get_log_level())) return;
                 strategy.logger->log(record, strategy.formatter->format(record));
                 return;
             }
             for (const auto& strategy : m_loggers) {
                 if (strategy.single_mode) continue;
                 if (!strategy.enabled) continue;
+                if (static_cast<int>(record.log_level) < static_cast<int>(strategy.logger->get_log_level())) continue;
                 strategy.logger->log(record, strategy.formatter->format(record));
             }
         }

include/logit_cpp/logit/loggers/ConsoleLogger.hpp

@@ -161,6 +161,16 @@ namespace logit {
             return 0.0;
         }
 
+        /// \brief Sets the minimal log level for this logger.
+        void set_log_level(LogLevel level) override {
+            m_log_level = static_cast<int>(level);
+        }
+
+        /// \brief Gets the minimal log level for this logger.
+        LogLevel get_log_level() const override {
+            return static_cast<LogLevel>(m_log_level.load());
+        }
+
         /// \brief Waits for all asynchronous tasks to complete.
         /// If asynchronous logging is enabled, waits for all pending log messages to be written.
         void wait() override {
@@ -179,6 +189,7 @@ namespace logit {
         mutable std::mutex m_mutex;     ///< Mutex to protect console output
         Config             m_config;    ///< Configuration for the console logger.
         std::atomic<int64_t> m_last_log_ts = ATOMIC_VAR_INIT(0);
+        std::atomic<int>    m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));
 
 #       if defined(_WIN32)
 

include/logit_cpp/logit/loggers/FileLogger.hpp

@@ -34,10 +34,13 @@ namespace logit {
         std::string get_string_param(const LoggerParam&) const override { return {}; }
         int64_t get_int_param(const LoggerParam&) const override { return 0; }
         double get_float_param(const LoggerParam&) const override { return 0.0; }
+        void set_log_level(LogLevel) override {}
+        LogLevel get_log_level() const override { return LogLevel::LOG_LVL_TRACE; }
         void wait() override {}
 
     private:
         void warn() const { std::cerr << "FileLogger is not supported under Emscripten" << std::endl; }
+        std::atomic<int> m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));
     };
 
 #else
@@ -164,6 +167,16 @@ namespace logit {
             return 0.0;
         }
 
+        /// \brief Sets the minimal log level for this logger.
+        void set_log_level(LogLevel level) override {
+            m_log_level = static_cast<int>(level);
+        }
+
+        /// \brief Gets the minimal log level for this logger.
+        LogLevel get_log_level() const override {
+            return static_cast<LogLevel>(m_log_level.load());
+        }
+
         /// \brief Waits for all asynchronous tasks to complete.
         void wait() override {
             if (!m_config.async) return;
@@ -179,6 +192,7 @@ namespace logit {
         std::string        m_file_name; ///< Name of the currently open log file.
         int64_t            m_current_date_ts = 0; ///< Timestamp of the current log file's date.
         std::atomic<int64_t> m_last_log_ts = ATOMIC_VAR_INIT(0); ///< Timestamp of the last log.
+        std::atomic<int>    m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));
 
         /// \brief Starts the logging process by initializing the file and directory.
         void start_logging() {

include/logit_cpp/logit/loggers/ILogger.hpp

@@ -21,6 +21,7 @@
 
 namespace logit {
 
+
     /// \interface ILogger
     /// \brief Interface for loggers that handle log message output.
     class ILogger {
@@ -54,6 +55,14 @@ namespace logit {
         /// \return A double representing the requested parameter.
         virtual double get_float_param(const LoggerParam& param) const = 0;
 
+        /// \brief Sets the minimal log level for this logger.
+        /// \param level Minimum log level.
+        virtual void set_log_level(LogLevel level) = 0;
+
+        /// \brief Gets the minimal log level for this logger.
+        /// \return Current minimal log level.
+        virtual LogLevel get_log_level() const = 0;
+
         /// \brief Waits for all asynchronous logging operations to complete.
         ///
         /// This pure virtual function must be implemented by derived logger classes.

include/logit_cpp/logit/loggers/UniqueFileLogger.hpp

@@ -40,10 +40,13 @@ namespace logit {
         std::string get_string_param(const LoggerParam&) const override { return {}; }
         int64_t get_int_param(const LoggerParam&) const override { return 0; }
         double get_float_param(const LoggerParam&) const override { return 0.0; }
+        void set_log_level(LogLevel) override {}
+        LogLevel get_log_level() const override { return LogLevel::LOG_LVL_TRACE; }
         void wait() override {}
 
     private:
         void warn() const { std::cerr << "UniqueFileLogger is not supported under Emscripten" << std::endl; }
+        std::atomic<int> m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));
     };
 
 #else
@@ -236,6 +239,16 @@ namespace logit {
             return 0.0;
         }
 
+        /// \brief Sets the minimal log level for this logger.
+        void set_log_level(LogLevel level) override {
+            m_log_level = static_cast<int>(level);
+        }
+
+        /// \brief Gets the minimal log level for this logger.
+        LogLevel get_log_level() const override {
+            return static_cast<LogLevel>(m_log_level.load());
+        }
+
         /// \brief Waits for all asynchronous tasks to complete.
         void wait() override {
             if (!m_config.async) return;
@@ -268,6 +281,7 @@ namespace logit {
         std::unordered_map<std::thread::id, ThreadLogInfo> m_thread_log_info; ///< Map to store log information per thread.
 
         std::atomic<int64_t> m_last_log_ts = ATOMIC_VAR_INIT(0); ///< Timestamp of the last log.
+        std::atomic<int>    m_log_level = ATOMIC_VAR_INIT(static_cast<int>(LogLevel::LOG_LVL_TRACE));
 
 
         /// \brief Starts the logging process by initializing the directory and removing old logs.