logger_interface.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <algorithm>
#include <array>
#include <chrono>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <utility>
#include "../patterns/result.h"
#include "../utils/enum_serialization.h"
#include "../utils/source_location.h"
 
namespace kcenon::common {
namespace interfaces {
 
enum class log_level {
    trace = 0,
    debug = 1,
    info = 2,
    warning = 3,
    warn = 3,       
    error = 4,
    critical = 5,
    fatal = 5,      
    off = 6
};
 
}  // namespace interfaces
 
template<>
struct enum_traits<interfaces::log_level> {
    static constexpr auto values = std::array{
        std::pair{interfaces::log_level::trace, std::string_view{"TRACE"}},
        std::pair{interfaces::log_level::debug, std::string_view{"DEBUG"}},
        std::pair{interfaces::log_level::info, std::string_view{"INFO"}},
        std::pair{interfaces::log_level::warning, std::string_view{"WARNING"}},
        std::pair{interfaces::log_level::error, std::string_view{"ERROR"}},
        std::pair{interfaces::log_level::critical, std::string_view{"CRITICAL"}},
        std::pair{interfaces::log_level::off, std::string_view{"OFF"}},
    };
    static constexpr std::string_view module_name = "logger_interface";
};
 
namespace interfaces {
 
struct log_entry {
    log_level level;
    std::string message;
    std::string file;
    int line;
    std::string function;
    std::chrono::system_clock::time_point timestamp;
    source_location location;  
 
    log_entry(log_level lvl = log_level::info,
              const std::string& msg = "")
        : level(lvl)
        , message(msg)
        , line(0)
        , timestamp(std::chrono::system_clock::now())
        , location() {}
 
    static log_entry create(
        log_level lvl,
        std::string_view msg,
        const source_location& loc = source_location::current()) {
 
        log_entry entry;
        entry.level = lvl;
        entry.message = std::string(msg);
        entry.file = loc.file_name();
        entry.line = loc.line();
        entry.function = loc.function_name();
        entry.timestamp = std::chrono::system_clock::now();
        entry.location = loc;
        return entry;
    }
};
 
class ILogger {
public:
    virtual ~ILogger() = default;
 
    virtual VoidResult log(log_level level, const std::string& message) = 0;
 
    virtual VoidResult log(log_level level,
                           std::string_view message,
                           const source_location& loc = source_location::current()) {
        // Default implementation delegates to simple log method
        // Derived classes should override to use source location information
        (void)loc;  // Unused in default implementation
        return log(level, std::string(message));
    }
 
    virtual VoidResult log(const log_entry& entry) = 0;
 
    virtual bool is_enabled(log_level level) const = 0;
 
    virtual VoidResult set_level(log_level level) = 0;
 
    virtual log_level get_level() const = 0;
 
    virtual VoidResult flush() = 0;
};
 
using LoggerFactory = std::function<std::shared_ptr<ILogger>()>;
 
class ILoggerProvider {
public:
    virtual ~ILoggerProvider() = default;
 
    virtual std::shared_ptr<ILogger> get_logger() = 0;
 
    virtual std::shared_ptr<ILogger> create_logger(const std::string& name) = 0;
};
 
struct logger_config {
    log_level min_level = log_level::info;
    std::string pattern = "[%Y-%m-%d %H:%M:%S.%e] [%l] %v";
    bool async_mode = false;
    size_t queue_size = 8192;
    bool color_enabled = false;
 
    logger_config() = default;
 
    logger_config(log_level level, const std::string& fmt = "")
        : min_level(level)
        , pattern(fmt.empty() ? pattern : fmt) {}
};
 
class ILoggerRegistry {
public:
    virtual ~ILoggerRegistry() = default;
 
    virtual VoidResult register_logger(const std::string& name, std::shared_ptr<ILogger> logger) = 0;
 
    virtual std::shared_ptr<ILogger> get_logger(const std::string& name) = 0;
 
    virtual VoidResult unregister_logger(const std::string& name) = 0;
 
    virtual std::shared_ptr<ILogger> get_default_logger() = 0;
 
    virtual VoidResult set_default_logger(std::shared_ptr<ILogger> logger) = 0;
};
 
inline std::string to_string(log_level level) {
    return enum_to_string(level);
}
 
inline log_level from_string(const std::string& str) {
    std::string upper(str.size(), '\0');
    std::transform(str.begin(), str.end(), upper.begin(),
                   [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
 
    // Handle aliases first
    if (upper == "WARN") {
        return log_level::warning;
    }
    if (upper == "FATAL") {
        return log_level::critical;
    }
 
    // Use generic template for standard values
    auto result = enum_from_string<log_level>(str);
    return result.is_ok() ? result.value() : log_level::info;  // default
}
 
}  // namespace interfaces
}  // namespace kcenon::common