logger_integration.h

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.
 
#pragma once
#ifndef KCENON_NETWORK_INTERNAL_INTEGRATION_LOGGER_INTEGRATION_H_
#define KCENON_NETWORK_INTERNAL_INTEGRATION_LOGGER_INTEGRATION_H_
 
#include <kcenon/network/detail/config/feature_flags.h>
 
#include <atomic>
#include <memory>
#include <string>
#include <string_view>
 
#include "kcenon/network/integration/thread_integration.h"
 
// Conditionally include common_system logging facilities
#if KCENON_WITH_COMMON_SYSTEM
#include <kcenon/common/logging/log_macros.h>
#include <kcenon/common/interfaces/global_logger_registry.h>
#endif
 
namespace kcenon::network::integration {
 
enum class log_level : int {
    trace = 0,
    debug = 1,
    info = 2,
    warn = 3,
    error = 4,
    fatal = 5
};
 
#if KCENON_WITH_COMMON_SYSTEM
inline kcenon::common::interfaces::log_level to_common_level(log_level level) {
    switch (level) {
        case log_level::trace: return kcenon::common::interfaces::log_level::trace;
        case log_level::debug: return kcenon::common::interfaces::log_level::debug;
        case log_level::info: return kcenon::common::interfaces::log_level::info;
        case log_level::warn: return kcenon::common::interfaces::log_level::warning;
        case log_level::error: return kcenon::common::interfaces::log_level::error;
        case log_level::fatal: return kcenon::common::interfaces::log_level::critical;
        default: return kcenon::common::interfaces::log_level::info;
    }
}
#endif // KCENON_WITH_COMMON_SYSTEM
 
class logger_interface {
public:
    virtual ~logger_interface() = default;
 
    virtual void log(log_level level, const std::string& message) = 0;
 
    virtual void log(log_level level, const std::string& message,
                    const std::string& file, int line,
                    const std::string& function) = 0;
 
    virtual bool is_level_enabled(log_level level) const = 0;
 
    virtual void flush() = 0;
};
 
#if KCENON_WITH_COMMON_SYSTEM
class common_system_logger_adapter : public logger_interface {
public:
    explicit common_system_logger_adapter(const std::string& logger_name = "");
 
    ~common_system_logger_adapter() override = default;
 
    void log(log_level level, const std::string& message) override;
    void log(log_level level, const std::string& message,
            const std::string& file, int line,
            const std::string& function) override;
    bool is_level_enabled(log_level level) const override;
    void flush() override;
 
private:
    std::string logger_name_;
    std::shared_ptr<kcenon::common::interfaces::ILogger> get_logger() const;
};
#endif // KCENON_WITH_COMMON_SYSTEM
 
class basic_logger : public logger_interface {
public:
    explicit basic_logger(log_level min_level = log_level::info);
 
    ~basic_logger() override;
 
    // logger_interface implementation
    void log(log_level level, const std::string& message) override;
    void log(log_level level, const std::string& message,
            const std::string& file, int line,
            const std::string& function) override;
    bool is_level_enabled(log_level level) const override;
    void flush() override;
 
    void set_min_level(log_level level);
 
    log_level get_min_level() const;
 
private:
    class impl;
    std::unique_ptr<impl> pimpl_;
};
 
class logger_integration_manager {
public:
    static logger_integration_manager& instance();
 
    void set_logger(std::shared_ptr<logger_interface> logger);
 
    std::shared_ptr<logger_interface> get_logger();
 
    void log(log_level level, const std::string& message);
 
    void log(log_level level, const std::string& message,
            const std::string& file, int line, const std::string& function);
 
private:
    logger_integration_manager();
    ~logger_integration_manager();
 
    class impl;
    std::unique_ptr<impl> pimpl_;
};
 
// =============================================================================
// Static destruction guard
//
// When KCENON_WITH_COMMON_SYSTEM is enabled, LOG_* macros access common_system's
// GlobalLoggerRegistry singleton. During static destruction, this singleton may
// be destroyed before network_system's singletons, causing heap corruption when
// thread pool threads try to log.
//
// This guard prevents logging during static destruction by tracking if the
// logging subsystem is still valid.
// =============================================================================
 
namespace detail {
 
class static_destruction_guard {
public:
    static_destruction_guard() { counter_.fetch_add(1, std::memory_order_relaxed); }
    ~static_destruction_guard() { counter_.fetch_sub(1, std::memory_order_relaxed); }
 
    static bool is_logging_safe()
    {
        return counter_.load(std::memory_order_relaxed) > 0;
    }
 
private:
    static inline std::atomic<int> counter_{0};
};
 
// This static instance ensures the counter is incremented at program start
// and decremented during static destruction. When counter_ reaches 0,
// we know static destruction has begun.
inline static_destruction_guard global_guard_;
 
} // namespace detail
 
} // namespace kcenon::network::integration
 
// =============================================================================
// Convenience macros for logging with automatic source location
//
// When KCENON_WITH_COMMON_SYSTEM is enabled, delegate to common_system's LOG_* macros.
// Otherwise, use logger_integration_manager for standalone operation.
//
// Note: All macros now check static_destruction_guard to avoid heap corruption
// during static destruction when common_system's GlobalLoggerRegistry is destroyed.
// =============================================================================
 
#if KCENON_WITH_COMMON_SYSTEM
 
#define NETWORK_LOG_TRACE(msg) \
    do { if (::kcenon::network::integration::detail::static_destruction_guard::is_logging_safe()) { LOG_TRACE(msg); } } while(0)
#define NETWORK_LOG_DEBUG(msg) \
    do { if (::kcenon::network::integration::detail::static_destruction_guard::is_logging_safe()) { LOG_DEBUG(msg); } } while(0)
#define NETWORK_LOG_INFO(msg) \
    do { if (::kcenon::network::integration::detail::static_destruction_guard::is_logging_safe()) { LOG_INFO(msg); } } while(0)
#define NETWORK_LOG_WARN(msg) \
    do { if (::kcenon::network::integration::detail::static_destruction_guard::is_logging_safe()) { LOG_WARNING(msg); } } while(0)
#define NETWORK_LOG_ERROR(msg) \
    do { if (::kcenon::network::integration::detail::static_destruction_guard::is_logging_safe()) { LOG_ERROR(msg); } } while(0)
#define NETWORK_LOG_FATAL(msg) \
    do { if (::kcenon::network::integration::detail::static_destruction_guard::is_logging_safe()) { LOG_CRITICAL(msg); } } while(0)
 
#else // KCENON_WITH_COMMON_SYSTEM
 
#define NETWORK_LOG_TRACE(msg) \
    kcenon::network::integration::logger_integration_manager::instance().log( \
        kcenon::network::integration::log_level::trace, msg, __FILE__, __LINE__, __FUNCTION__)
 
#define NETWORK_LOG_DEBUG(msg) \
    kcenon::network::integration::logger_integration_manager::instance().log( \
        kcenon::network::integration::log_level::debug, msg, __FILE__, __LINE__, __FUNCTION__)
 
#define NETWORK_LOG_INFO(msg) \
    kcenon::network::integration::logger_integration_manager::instance().log( \
        kcenon::network::integration::log_level::info, msg, __FILE__, __LINE__, __FUNCTION__)
 
#define NETWORK_LOG_WARN(msg) \
    kcenon::network::integration::logger_integration_manager::instance().log( \
        kcenon::network::integration::log_level::warn, msg, __FILE__, __LINE__, __FUNCTION__)
 
#define NETWORK_LOG_ERROR(msg) \
    kcenon::network::integration::logger_integration_manager::instance().log( \
        kcenon::network::integration::log_level::error, msg, __FILE__, __LINE__, __FUNCTION__)
 
#define NETWORK_LOG_FATAL(msg) \
    kcenon::network::integration::logger_integration_manager::instance().log( \
        kcenon::network::integration::log_level::fatal, msg, __FILE__, __LINE__, __FUNCTION__)
 
#endif // KCENON_WITH_COMMON_SYSTEM
 
// Backward compatibility namespace alias is defined in thread_integration.h
 
#endif // KCENON_NETWORK_INTERNAL_INTEGRATION_LOGGER_INTEGRATION_H_