thread_logger.hpp

Go to the documentation of this file.

#pragma once
#if __cplusplus >= 202002L && defined(__cpp_lib_format)
#  include <format>
#  include <stdexcept>  // 用于std::format_error / For std::format_error
#endif
#include <atomic>
#include <condition_variable>
#include <map>
#include <mutex>
#include <queue>
#include <sstream>
#include <string>
#include <thread>
#include <tuple>
#include <type_traits>
#include <unordered_map>
 
#include <cpp-toolbox/cpp-toolbox_export.hpp>
 
#include "cpp-toolbox/macro.hpp"
 
// 包含并发队列头文件 / Include the concurrent queue header
#include "cpp-toolbox/container/concurrent_queue.hpp"
 
// 包含对象池 / Include object pool
#include "cpp-toolbox/base/object_pool.hpp"
 
// #define PROJECT_SOURCE_DIR
 
// !TODO: Why docxgen doesn't work?
 
namespace toolbox::logger
{
 
template<typename T, typename = void>
struct CPP_TOOLBOX_EXPORT is_container : std::false_type
{
};
 
template<typename T>
struct CPP_TOOLBOX_EXPORT
    is_container<T,
                 std::void_t<typename T::value_type,
                             typename T::iterator,
                             decltype(std::declval<T>().begin()),
                             decltype(std::declval<T>().end())>>
    : std::true_type
{
};
 
template<typename T>
inline constexpr bool is_container_v = is_container<T>::value;
 
template<typename T>
struct CPP_TOOLBOX_EXPORT has_stream_operator
{
  template<typename U>
  static auto test(int) -> std::is_same<decltype(std::declval<std::ostream&>()
                                                 << std::declval<const U&>()),
                                        std::ostream&>;
 
  template<typename>
  static auto test(...) -> std::false_type;
 
  static constexpr bool value = decltype(test<T>(0))::value;
};
 
template<typename T>
inline constexpr bool has_stream_operator_v = has_stream_operator<T>::value;
 
template<typename T>
struct CPP_TOOLBOX_EXPORT has_ostream_method
{
  template<typename U>
  static auto test(int) -> std::is_same<
      decltype(std::declval<U>().operator<<(std::declval<std::ostream&>())),
      std::ostream&>;
 
  template<typename>
  static auto test(...) -> std::false_type;
 
  static constexpr bool value = decltype(test<T>(0))::value;
};
 
template<typename T>
inline constexpr bool has_ostream_method_v = has_ostream_method<T>::value;
 
class CPP_TOOLBOX_EXPORT thread_logger_t
{
public:
  enum class Level : uint8_t
  {
    TRACE,  
    DEBUG,  
    INFO,  
    WARN,  
    ERR,  
    CRITICAL  
  };
 
  static auto instance() -> thread_logger_t&;
 
  auto level() -> Level { return level_; }
 
  auto level_str() -> std::string { return level_to_string(level_); }
 
  auto set_level(Level level) -> void { level_ = level; }
 
  class CPP_TOOLBOX_EXPORT thread_format_logger_t
  {
  public:
    thread_format_logger_t(thread_logger_t& logger, Level level);
 
    template<typename... Args>
    void operator()(const char* format, Args&&... args)
    {
      if (level_ < logger_.level()) {
        return;
      }
 
#if __cplusplus >= 202002L && defined(__cpp_lib_format)
      // C++20: 使用std::format以获得更好的性能和标准合规性 / Use std::format
      // for better performance and standard compliance
      try {
        std::string message = std::format(format, std::forward<Args>(args)...);
        logger_.enqueue(level_, std::move(message));
      } catch (const std::format_error& e) {
        // 优雅地处理潜在的格式错误 / Handle potential format errors gracefully
        std::string error_message = "[Formatting Error] ";
        error_message += e.what();
        error_message += " | Original format: '";
        error_message += format;
        error_message += "'";
        logger_.enqueue(Level::ERR, std::move(error_message));
      }
#else
      // Pre-C++20: 使用现有的自定义format_message实现 / Use the existing custom
      // format_message implementation
      std::string message = format_message(format, std::forward<Args>(args)...);
      logger_.enqueue(level_, std::move(message));
#endif
    }
 
  private:
    static auto format_message(const char* format) -> std::string
    {
      return {format};  // 无参数的简单实现 / Simple implementation for no args
    }
 
    template<typename T, typename... Args>
    auto format_message(const char* format, T&& value, Args&&... args)
        -> std::string
    {
      std::string result;
      while (*format) {
        if (*format == '{' && *(format + 1) == '}') {
          std::stringstream ss;
          ss << value;
          result += ss.str();
          return result
              + format_message(format + 2, std::forward<Args>(args)...);
        }
        result += *format++;
      }
      return result;
    }
 
    thread_logger_t&
        logger_;  
    Level level_;  
  };
 
  class CPP_TOOLBOX_EXPORT thread_stream_logger_t
  {
  public:
    thread_stream_logger_t(
        thread_logger_t& logger,
        Level level,
        toolbox::base::object_pool_t<std::stringstream>& pool);
 
    ~thread_stream_logger_t();
 
    // 删除复制/移动构造函数/赋值运算符 / Deleted copy/move
    // constructors/assignments
    thread_stream_logger_t(const thread_stream_logger_t&) = delete;
    thread_stream_logger_t& operator=(const thread_stream_logger_t&) = delete;
    thread_stream_logger_t(thread_stream_logger_t&&) = delete;
    thread_stream_logger_t& operator=(thread_stream_logger_t&&) = delete;
 
    auto str() -> std::string
    {
      return ss_ptr_->str();
    }  // 使用指针 / Use pointer
 
    template<typename T>
    auto operator<<(const T& container)
        -> std::enable_if_t<is_container_v<T> && !has_stream_operator_v<T>,
                            thread_stream_logger_t&>
    {
      if (level_ < logger_.level()) {
        return *this;
      }
      *ss_ptr_ << "[";  // 使用指针 / Use pointer
      bool first = true;
      for (const auto& item : container) {
        if (!first) {
          *ss_ptr_ << ", ";
        }
        *ss_ptr_ << item;  // 使用指针 / Use pointer
        first = false;
      }
      *ss_ptr_ << "]";  // 使用指针 / Use pointer
      return *this;
    }
 
    template<typename... Args>
    auto operator<<(const std::tuple<Args...>& t) -> thread_stream_logger_t&
    {
      if (level_ < logger_.level()) {
        return *this;
      }
      print_tuple(t, std::index_sequence_for<Args...> {});
      return *this;
    }
 
    auto red(const std::string& text) -> thread_stream_logger_t&;
 
    auto green(const std::string& text) -> thread_stream_logger_t&;
 
    auto yellow(const std::string& text) -> thread_stream_logger_t&;
 
    auto bold(const std::string& text) -> thread_stream_logger_t&;
 
    auto operator<<(const char* value) -> thread_stream_logger_t&
    {
      if (level_ < logger_.level()) {
        return *this;
      }
      *ss_ptr_ << value;  // 使用指针 / Use pointer
      return *this;
    }
 
    template<typename T>
    auto operator<<(const T& value)
        -> std::enable_if_t<has_stream_operator_v<T>, thread_stream_logger_t&>
    {
      if (level_ < logger_.level()) {
        return *this;
      }
      *ss_ptr_ << value;  // Use pointer
      return *this;
    }
 
    template<typename T>
    auto operator<<(T&& value)
        -> std::enable_if_t<!has_stream_operator_v<T>
                                && has_ostream_method_v<T>,
                            thread_stream_logger_t&>
    {
      if (level_ < logger_.level()) {
        return *this;
      }
      value.operator<<(*ss_ptr_);  // 使用指针 / Use pointer
      return *this;
    }
 
    auto operator<<(thread_stream_logger_t& logger) -> thread_stream_logger_t&
    {
      *ss_ptr_ << logger.str();  // 使用指针 / Use pointer
      return *this;
    }
 
    template<typename K, typename V>
    auto operator<<(const std::map<K, V>& map) -> thread_stream_logger_t&
    {
      if (level_ < logger_.level()) {
        return *this;
      }
      *ss_ptr_ << "{";  // 使用指针 / Use pointer
      bool first = true;
      for (const auto& [key, value] : map) {
        if (!first) {
          *ss_ptr_ << ", ";
        }
        *ss_ptr_ << key << ": " << value;  // 使用指针 / Use pointer
        first = false;
      }
      *ss_ptr_ << "}";  // 使用指针 / Use pointer
      return *this;
    }
 
    template<typename K, typename V>
    auto operator<<(const std::unordered_map<K, V>& map)
        -> thread_stream_logger_t&
    {
      if (level_ < logger_.level())
        return *this;
      *ss_ptr_ << "{";  // 使用指针 / Use pointer
      bool first = true;
      for (const auto& [key, value] : map) {
        if (!first)
          *ss_ptr_ << ", ";
        *ss_ptr_ << key << ": " << value;  // 使用指针 / Use pointer
        first = false;
      }
      *ss_ptr_ << "}";  // 使用指针 / Use pointer
      return *this;
    }
 
  private:
    template<typename Tuple, size_t... Is>
    auto print_tuple(const Tuple& t, std::index_sequence<Is...>) -> void
    {
      if (level_ < logger_.level()) {
        return;
      }
      *ss_ptr_ << "(";  // 使用指针 / Use pointer
      ((*ss_ptr_ << (Is == 0 ? "" : ", ") << std::get<Is>(t)), ...);
      *ss_ptr_ << ")";  // 使用指针 / Use pointer
    }
 
    thread_logger_t&
        logger_;  
    Level level_;  
    // 将stringstream存储在从池中获取的unique_ptr中 / Store the stringstream in
    // a unique_ptr obtained from the pool
    toolbox::base::object_pool_t<std::stringstream>::PooledObjectPtr ss_ptr_;
  };
 
  auto trace_f() -> thread_format_logger_t { return {*this, Level::TRACE}; }
 
  auto debug_f() -> thread_format_logger_t { return {*this, Level::DEBUG}; }
 
  auto info_f() -> thread_format_logger_t { return {*this, Level::INFO}; }
 
  auto warn_f() -> thread_format_logger_t { return {*this, Level::WARN}; }
 
  auto error_f() -> thread_format_logger_t { return {*this, Level::ERR}; }
 
  auto critical_f() -> thread_format_logger_t
  {
    return {*this, Level::CRITICAL};
  }
 
  auto trace_s() -> thread_stream_logger_t
  {
    return {*this, Level::TRACE, stringstream_pool_};
  }
 
  auto debug_s() -> thread_stream_logger_t
  {
    return {*this, Level::DEBUG, stringstream_pool_};
  }
 
  auto info_s() -> thread_stream_logger_t
  {
    return {*this, Level::INFO, stringstream_pool_};
  }
 
  auto warn_s() -> thread_stream_logger_t
  {
    return {*this, Level::WARN, stringstream_pool_};
  }
 
  auto error_s() -> thread_stream_logger_t
  {
    return {*this, Level::ERR, stringstream_pool_};
  }
 
  auto critical_s() -> thread_stream_logger_t
  {
    return {*this, Level::CRITICAL, stringstream_pool_};
  }
 
  static void shutdown();
 
private:
  // 构造函数保持私有 / Constructor remains private
  thread_logger_t();
  // 删除复制/移动操作 / Delete copy/move operations
  thread_logger_t(const thread_logger_t&) = delete;
  auto operator=(const thread_logger_t&) -> thread_logger_t& = delete;
  thread_logger_t(thread_logger_t&&) = delete;
  auto operator=(thread_logger_t&&) -> thread_logger_t& = delete;
 
  void start();
  void stop();
  void enqueue(Level level, std::string message);
  void processLogs();
 
  static auto level_to_string(Level level) -> std::string;
 
  // 队列成员保持不变 / Queue member remains
  toolbox::container::concurrent_queue_t<std::pair<Level, std::string>> queue_;
  // 工作线程成员保持不变 / Worker thread member remains
  std::thread worker_;
  std::atomic<bool> running_ {false};
  Level level_ = Level::INFO;
 
  // 单例模式的静态成员 / Static members for singleton pattern
  static std::atomic<thread_logger_t*> instance_ptr_;
  static std::mutex instance_mutex_;
  static std::atomic<bool> shutdown_called_;
 
  // 添加字符串流池 / Add the stringstream pool
  toolbox::base::object_pool_t<std::stringstream> stringstream_pool_;
};
 
}  // namespace toolbox::logger
 
#define LOG_TRACE_F toolbox::logger::thread_logger_t::instance().trace_f()
#define LOG_DEBUG_F toolbox::logger::thread_logger_t::instance().debug_f()
#define LOG_INFO_F toolbox::logger::thread_logger_t::instance().info_f()
#define LOG_WARN_F toolbox::logger::thread_logger_t::instance().warn_f()
#define LOG_ERROR_F toolbox::logger::thread_logger_t::instance().error_f()
#define LOG_CRITICAL_F toolbox::logger::thread_logger_t::instance().critical_f()
 
#define LOG_TRACE_S toolbox::logger::thread_logger_t::instance().trace_s()
#define LOG_DEBUG_S toolbox::logger::thread_logger_t::instance().debug_s()
#define LOG_INFO_S toolbox::logger::thread_logger_t::instance().info_s()
#define LOG_WARN_S toolbox::logger::thread_logger_t::instance().warn_s()
#define LOG_ERROR_S toolbox::logger::thread_logger_t::instance().error_s()
#define LOG_CRITICAL_S toolbox::logger::thread_logger_t::instance().critical_s()
 
#define LOG_DEBUG_D(x) \
  LOG_DEBUG_S << __FILE__ << ":" << __LINE__ << " (" << __CURRENT_FUNCTION__ \
              << ") " << x
#define LOG_INFO_D(x) \
  LOG_INFO_S << __FILE__ << ":" << __LINE__ << " (" << __CURRENT_FUNCTION__ \
             << ") " << x
#define LOG_WARN_D(x) \
  LOG_WARN_S << __FILE__ << ":" << __LINE__ << " (" << __CURRENT_FUNCTION__ \
             << ") " << x
#define LOG_ERROR_D(x) \
  LOG_ERROR_S << __FILE__ << ":" << __LINE__ << " (" << __CURRENT_FUNCTION__ \
              << ") " << x
#define LOG_CRITICAL_D(x) \
  LOG_CRITICAL_S << __FILE__ << ":" << __LINE__ << " (" \
                 << __CURRENT_FUNCTION__ << ") " << x