core.cppm

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.
 
export module kcenon.logger:core;
 
// Standard library imports
import <atomic>;
import <chrono>;
import <memory>;
import <mutex>;
import <string>;
import <string_view>;
import <thread>;
import <vector>;
 
// Import common_system dependencies
import kcenon.common;
 
// Export core classes
export {
    // Include the actual headers - these will be converted to module implementation
    // For now, we re-export the header content as module interface
 
    // Core types and enumerations
    namespace logger_system {
        enum class overflow_policy {
            block,
            drop_oldest,
            drop_newest,
            grow
        };
 
        enum class health_status {
            healthy,
            degraded,
            unhealthy,
            critical
        };
 
        enum class logger_error_code {
            success = 0,
            invalid_configuration,
            writer_not_found,
            writer_already_exists,
            write_failed,
            flush_failed,
            buffer_full,
            invalid_level,
            invalid_pattern,
            file_open_failed,
            network_error,
            encryption_error,
            compression_error,
            monitoring_failed,
            component_not_found,
            di_resolution_failed,
            health_check_failed,
            writer_closed,
            unknown_error
        };
    }
 
    // Core namespace exports
    namespace kcenon::logger {
        // Type aliases - use common::interfaces::log_level
        using log_level = common::interfaces::log_level;
        using health_status = logger_system::health_status;
        using overflow_policy = logger_system::overflow_policy;
 
        namespace core {
            struct log_context {
                std::string_view file{"unknown"};
                int line{0};
                std::string_view function{"unknown"};
                std::thread::id thread_id{std::this_thread::get_id()};
                std::chrono::time_point<std::chrono::system_clock> timestamp{
                    std::chrono::system_clock::now()};
            };
 
            inline log_context make_log_context(std::string_view file,
                                                int line,
                                                std::string_view function) {
                log_context ctx;
                ctx.file = file;
                ctx.line = line;
                ctx.function = function;
                ctx.thread_id = std::this_thread::get_id();
                ctx.timestamp = std::chrono::system_clock::now();
                return ctx;
            }
        }
 
        // Forward declarations for core classes
        class logger;
        class log_collector;
        class base_writer;
        class console_writer;
        class file_writer;
        class rotating_file_writer;
        class network_writer;
        class async_writer;
        class batch_writer;
        class critical_writer;
        class composite_writer;
 
        // Forward declarations for formatters
        namespace formatters {
            class base_formatter;
            class json_formatter;
            class timestamp_formatter;
        }
 
        // Forward declarations for filters
        namespace filters {
            class log_filter;
        }
 
        // Forward declarations for interfaces
        class log_entry;
        class log_filter_interface;
        class log_formatter_interface;
        class log_writer_interface;
        class log_sink_interface;
        class output_sink_interface;
 
        // Forward declarations for metrics
        namespace metrics {
            struct logger_performance_stats;
        }
 
        // Forward declarations for security
        namespace security {
            class signal_manager;
            class critical_logger_interface;
        }
 
        // Forward declarations for strategies
        namespace strategies {
            class config_strategy_interface;
            class deployment_strategy;
            class environment_strategy;
            class performance_strategy;
            class composite_strategy;
        }
 
        // Forward declarations for builders
        class logger_builder;
        class logger_config_builder;
        struct logger_config;
    }
}