logger_integration.cpp

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#include <kcenon/network/detail/config/feature_flags.h>
 
#include "internal/integration/logger_integration.h"
#include <atomic>
#include <chrono>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <mutex>
#include <sstream>
 
namespace kcenon::network::integration {
 
// Helper function to convert log level to string
static const char* level_to_string(log_level level) {
    switch (level) {
        case log_level::trace: return "TRACE";
        case log_level::debug: return "DEBUG";
        case log_level::info:  return "INFO ";
        case log_level::warn:  return "WARN ";
        case log_level::error: return "ERROR";
        case log_level::fatal: return "FATAL";
        default: return "UNKN ";
    }
}
 
// Helper function to get current timestamp (thread-safe)
static std::string get_timestamp() {
    auto now = std::chrono::system_clock::now();
    auto time_t_val = std::chrono::system_clock::to_time_t(now);
    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        now.time_since_epoch()) % 1000;
 
    std::tm tm_buf{};
#ifdef _WIN32
    localtime_s(&tm_buf, &time_t_val);  // Windows thread-safe version
#else
    localtime_r(&time_t_val, &tm_buf);  // POSIX thread-safe version
#endif
 
    std::stringstream ss;
    ss << std::put_time(&tm_buf, "%Y-%m-%d %H:%M:%S");
    ss << '.' << std::setfill('0') << std::setw(3) << ms.count();
    return ss.str();
}
 
//============================================================================
// common_system_logger_adapter implementation (only when common_system available)
//============================================================================
 
#if KCENON_WITH_COMMON_SYSTEM
 
common_system_logger_adapter::common_system_logger_adapter(const std::string& logger_name)
    : logger_name_(logger_name) {}
 
std::shared_ptr<kcenon::common::interfaces::ILogger>
common_system_logger_adapter::get_logger() const {
    if (logger_name_.empty()) {
        return kcenon::common::interfaces::get_logger();
    }
    return kcenon::common::interfaces::get_logger(logger_name_);
}
 
void common_system_logger_adapter::log(log_level level, const std::string& message) {
    auto logger = get_logger();
    if (logger) {
        logger->log(to_common_level(level), message);
    }
}
 
void common_system_logger_adapter::log(log_level level, const std::string& message,
                                       const std::string& file, int line,
                                       const std::string& function) {
    auto logger = get_logger();
    if (logger) {
        // Use log_entry API for common_system v3.0.0 compatibility
        // See: https://github.com/kcenon/network_system/issues/338
        kcenon::common::interfaces::log_entry entry;
        entry.level = to_common_level(level);
        entry.message = message;
        entry.file = file;
        entry.line = line;
        entry.function = function;
        entry.timestamp = std::chrono::system_clock::now();
        logger->log(entry);
    }
}
 
bool common_system_logger_adapter::is_level_enabled(log_level level) const {
    auto logger = get_logger();
    return logger ? logger->is_enabled(to_common_level(level)) : false;
}
 
void common_system_logger_adapter::flush() {
    auto logger = get_logger();
    if (logger) {
        logger->flush();
    }
}
 
#endif // KCENON_WITH_COMMON_SYSTEM
 
//============================================================================
// basic_logger implementation
//============================================================================
 
class basic_logger::impl {
public:
    explicit impl(log_level min_level) : min_level_(static_cast<int>(min_level)) {}
 
    void log(log_level level, const std::string& message) {
        if (static_cast<int>(level) < min_level_) return;
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto timestamp = get_timestamp();
        std::ostringstream oss;
        oss << "[" << timestamp << "] "
            << "[" << level_to_string(level) << "] "
            << "[network_system] "
            << message;
 
        auto* target = (level >= log_level::error) ? stderr : stdout;
        const auto& record = oss.str();
        std::fwrite(record.data(), 1, record.size(), target);
        std::fputc('\n', target);
        std::fflush(target);
    }
 
    void log(log_level level, const std::string& message,
            const std::string& file, int line, const std::string& function) {
        if (static_cast<int>(level) < min_level_) return;
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto timestamp = get_timestamp();
        std::ostringstream oss;
        oss << "[" << timestamp << "] "
            << "[" << level_to_string(level) << "] "
            << "[network_system] "
            << message
            << " (" << file << ":" << line << " in " << function << ")";
 
        auto* target = (level >= log_level::error) ? stderr : stdout;
        const auto& record = oss.str();
        std::fwrite(record.data(), 1, record.size(), target);
        std::fputc('\n', target);
        std::fflush(target);
    }
 
    bool is_level_enabled(log_level level) const {
        return static_cast<int>(level) >= min_level_;
    }
 
    void flush() {
        std::lock_guard<std::mutex> lock(mutex_);
        std::fflush(stdout);
        std::fflush(stderr);
    }
 
    void set_min_level(log_level level) {
        min_level_ = static_cast<int>(level);
    }
 
    log_level get_min_level() const {
        return static_cast<log_level>(min_level_.load());
    }
 
private:
    mutable std::mutex mutex_;
    std::atomic<int> min_level_;
};
 
basic_logger::basic_logger(log_level min_level)
    : pimpl_(std::make_unique<impl>(min_level)) {}
 
basic_logger::~basic_logger() = default;
 
void basic_logger::log(log_level level, const std::string& message) {
    pimpl_->log(level, message);
}
 
void basic_logger::log(log_level level, const std::string& message,
                      const std::string& file, int line, const std::string& function) {
    pimpl_->log(level, message, file, line, function);
}
 
bool basic_logger::is_level_enabled(log_level level) const {
    return pimpl_->is_level_enabled(level);
}
 
void basic_logger::flush() {
    pimpl_->flush();
}
 
void basic_logger::set_min_level(log_level level) {
    pimpl_->set_min_level(level);
}
 
log_level basic_logger::get_min_level() const {
    return pimpl_->get_min_level();
}
 
//============================================================================
// logger_integration_manager implementation
//
// When KCENON_WITH_COMMON_SYSTEM is defined, uses common_system_logger_adapter.
// Otherwise, uses basic_logger for standalone operation.
//============================================================================
 
class logger_integration_manager::impl {
public:
    impl() {
#if KCENON_WITH_COMMON_SYSTEM
        // Use common_system_logger_adapter by default
        // It delegates to GlobalLoggerRegistry which provides NullLogger fallback
        logger_ = std::make_shared<common_system_logger_adapter>();
#else
        // Use basic_logger for standalone operation
        logger_ = std::make_shared<basic_logger>();
#endif
    }
 
    void set_logger(std::shared_ptr<logger_interface> logger) {
        std::lock_guard<std::mutex> lock(mutex_);
        logger_ = logger;
    }
 
    std::shared_ptr<logger_interface> get_logger() {
        std::lock_guard<std::mutex> lock(mutex_);
        if (!logger_) {
#if KCENON_WITH_COMMON_SYSTEM
            logger_ = std::make_shared<common_system_logger_adapter>();
#else
            logger_ = std::make_shared<basic_logger>();
#endif
        }
        return logger_;
    }
 
    void log(log_level level, const std::string& message) {
#if KCENON_WITH_COMMON_SYSTEM
        // Delegate directly to common_system's GlobalLoggerRegistry
        auto common_logger = kcenon::common::interfaces::get_logger();
        if (common_logger) {
            common_logger->log(to_common_level(level), message);
        }
#else
        auto logger = get_logger();
        if (logger) {
            logger->log(level, message);
        }
#endif
    }
 
    void log(log_level level, const std::string& message,
            const std::string& file, int line, const std::string& function) {
#if KCENON_WITH_COMMON_SYSTEM
        // Delegate directly to common_system's GlobalLoggerRegistry
        // Use log_entry API for common_system v3.0.0 compatibility
        auto common_logger = kcenon::common::interfaces::get_logger();
        if (common_logger) {
            kcenon::common::interfaces::log_entry entry;
            entry.level = to_common_level(level);
            entry.message = message;
            entry.file = file;
            entry.line = line;
            entry.function = function;
            entry.timestamp = std::chrono::system_clock::now();
            common_logger->log(entry);
        }
#else
        auto logger = get_logger();
        if (logger) {
            logger->log(level, message, file, line, function);
        }
#endif
    }
 
private:
    mutable std::mutex mutex_;
    std::shared_ptr<logger_interface> logger_;
};
 
logger_integration_manager& logger_integration_manager::instance() {
    // Intentionally leak the singleton to avoid destruction order issues
    // during sanitizer runs and shutdown hooks.
    static logger_integration_manager* instance = new logger_integration_manager();
    return *instance;
}
 
logger_integration_manager::logger_integration_manager()
    : pimpl_(std::make_unique<impl>()) {}
 
logger_integration_manager::~logger_integration_manager() = default;
 
void logger_integration_manager::set_logger(std::shared_ptr<logger_interface> logger) {
    pimpl_->set_logger(logger);
}
 
std::shared_ptr<logger_interface> logger_integration_manager::get_logger() {
    return pimpl_->get_logger();
}
 
void logger_integration_manager::log(log_level level, const std::string& message) {
    pimpl_->log(level, message);
}
 
void logger_integration_manager::log(log_level level, const std::string& message,
                                    const std::string& file, int line, const std::string& function) {
    pimpl_->log(level, message, file, line, function);
}
 
} // namespace kcenon::network::integration