kcenon::logger::logger::impl Class Reference

Collaboration diagram for kcenon::logger::logger::impl:

Public Member Functions
	impl (bool async, std::size_t buffer_size, std::unique_ptr< backends::integration_backend > backend)
	~impl ()
void	dispatch_to_writers (log_level level, const std::string &message, const std::string &file, int line, const std::string &function, const log_entry &entry)
	Dispatch log to writers with routing support.

Public Attributes
bool	async_mode_
std::size_t	buffer_size_
bool	running_
bool	metrics_enabled_
std::atomic< log_level >	min_level_
std::vector< std::shared_ptr< log_writer_interface > >	writers_
std::unordered_map< std::string, std::shared_ptr< log_writer_interface > >	named_writers_
std::shared_mutex	writers_mutex_
std::unique_ptr< backends::integration_backend >	backend_
std::unique_ptr< log_collector >	collector_
std::unique_ptr< log_filter_interface >	filter_
std::shared_mutex	filter_mutex_
std::unique_ptr< log_router >	router_
std::shared_mutex	router_mutex_
unified_log_context	context_
std::unique_ptr< sampling::log_sampler >	sampler_
std::shared_mutex	sampler_mutex_
char	emergency_buffer_ [emergency_buffer_size_]
std::atomic< size_t >	emergency_buffer_used_ {0}
std::atomic< int >	emergency_fd_ {-1}

Static Public Attributes
static constexpr size_t	emergency_buffer_size_ = 8192

Detailed Description

Definition at line 59 of file logger.cpp.

Constructor & Destructor Documentation

impl()

kcenon::logger::logger::impl::impl ( bool async, std::size_t buffer_size, std::unique_ptr< backends::integration_backend > backend )

inline

Definition at line 95 of file logger.cpp.

        : async_mode_(async), buffer_size_(buffer_size), running_(false), metrics_enabled_(false),
          min_level_(log_level::info), backend_(std::move(backend)),
          router_(std::make_unique<log_router>()) {
        // Reserve space to avoid reallocation during typical usage
        writers_.reserve(10);
 
        // Auto-detect backend if not provided
        // Users can provide thread_system_backend or other backends via constructor
        if (!backend_) {
            backend_ = std::make_unique<backends::standalone_backend>();
        }
 
        // Initialize backend if required
        if (backend_->requires_initialization()) {
            backend_->initialize();
        }
 
        // Create log collector for async mode
        if (async_mode_) {
            collector_ = std::make_unique<log_collector>(buffer_size_);
        }
    }

References async_mode_, backend_, buffer_size_, collector_, and writers_.

~impl()

kcenon::logger::logger::impl::~impl ( )

inline

Definition at line 119 of file logger.cpp.

            {
        if (backend_) {
            backend_->shutdown();
        }
    }

References backend_.

Member Function Documentation

dispatch_to_writers()

void kcenon::logger::logger::impl::dispatch_to_writers ( log_level level, const std::string & message, const std::string & file, int line, const std::string & function, const log_entry & entry )

inline

Dispatch log to writers with routing support.

Parameters

level	Log level
message	Log message
file	Source file
line	Source line
function	Source function
entry	Log entry for routing check

Definition at line 134 of file logger.cpp.

                                                    {
#ifdef LOGGER_WITH_ANALYSIS
        // Real-time analysis if analyzer is set
        {
            std::shared_lock<std::shared_mutex> lock(analyzer_mutex_);
            if (realtime_analyzer_) {
                analysis::analyzed_log_entry analyzed_entry;
                analyzed_entry.level = level;
                analyzed_entry.message = message;
                analyzed_entry.timestamp = entry.timestamp;
                analyzed_entry.source_file = file;
                analyzed_entry.source_line = line;
                analyzed_entry.function_name = function;
                realtime_analyzer_->analyze(analyzed_entry);
            }
        }
#endif  // LOGGER_WITH_ANALYSIS
 
        // Check routing rules
        std::vector<std::string> routed_writer_names;
        bool is_exclusive = false;
        {
            std::shared_lock<std::shared_mutex> lock(router_mutex_);
            if (router_) {
                routed_writer_names = router_->get_writers_for_log(entry);
                is_exclusive = router_->is_exclusive_routing();
            }
        }
 
        auto now = std::chrono::system_clock::now();
 
        if (is_exclusive) {
            // Exclusive mode: only send to matched routes
            // If no routes match, message is dropped (exclusive mode behavior)
            if (!routed_writer_names.empty()) {
                std::unordered_map<std::string, std::shared_ptr<log_writer_interface>> local_named_writers;
                {
                    std::shared_lock<std::shared_mutex> lock(writers_mutex_);
                    local_named_writers = named_writers_;
                }
 
                // Create log_entry for routing
                log_entry entry(level, message, file, line, function, now);
 
                for (const auto& writer_name : routed_writer_names) {
                    auto it = local_named_writers.find(writer_name);
                    if (it != local_named_writers.end() && it->second) {
                        it->second->write(entry);
                    }
                }
            }
            // No matched routes in exclusive mode = drop message
        } else {
            // Non-exclusive mode: send to all writers
            std::vector<std::shared_ptr<log_writer_interface>> local_writers;
            {
                std::shared_lock<std::shared_mutex> lock(writers_mutex_);
                local_writers = writers_;
            }
 
            // Create log_entry once for all writers
            log_entry entry(level, message, file, line, function, now);
 
            for (auto& writer : local_writers) {
                if (writer) {
                    writer->write(entry);
                }
            }
        }
    }

References kcenon::logger::analysis::analyzed_log_entry::function_name, kcenon::logger::analysis::analyzed_log_entry::level, kcenon::logger::analysis::analyzed_log_entry::message, named_writers_, router_, router_mutex_, kcenon::logger::analysis::analyzed_log_entry::source_file, kcenon::logger::analysis::analyzed_log_entry::source_line, kcenon::logger::analysis::analyzed_log_entry::timestamp, kcenon::logger::log_entry::timestamp, writers_, and writers_mutex_.

Member Data Documentation

async_mode_

bool kcenon::logger::logger::impl::async_mode_

Definition at line 61 of file logger.cpp.

Referenced by impl().

backend_

std::unique_ptr<backends::integration_backend> kcenon::logger::logger::impl::backend_

Definition at line 69 of file logger.cpp.

Referenced by impl(), and ~impl().

buffer_size_

std::size_t kcenon::logger::logger::impl::buffer_size_

Definition at line 62 of file logger.cpp.

Referenced by impl().

collector_

std::unique_ptr<log_collector> kcenon::logger::logger::impl::collector_

Definition at line 70 of file logger.cpp.

Referenced by impl().

context_

unified_log_context kcenon::logger::logger::impl::context_

Definition at line 83 of file logger.cpp.

emergency_buffer_

char kcenon::logger::logger::impl::emergency_buffer_[emergency_buffer_size_]

mutable

Definition at line 91 of file logger.cpp.

emergency_buffer_size_

size_t kcenon::logger::logger::impl::emergency_buffer_size_ = 8192

staticconstexpr

Definition at line 90 of file logger.cpp.

emergency_buffer_used_

std::atomic<size_t> kcenon::logger::logger::impl::emergency_buffer_used_ {0}

Definition at line 92 of file logger.cpp.

{0};  // Track how much is used

emergency_fd_

std::atomic<int> kcenon::logger::logger::impl::emergency_fd_ {-1}

Definition at line 93 of file logger.cpp.

{-1};  // File descriptor for emergency writes

filter_

std::unique_ptr<log_filter_interface> kcenon::logger::logger::impl::filter_

Definition at line 71 of file logger.cpp.

filter_mutex_

std::shared_mutex kcenon::logger::logger::impl::filter_mutex_

mutable

Definition at line 72 of file logger.cpp.

metrics_enabled_

bool kcenon::logger::logger::impl::metrics_enabled_

Definition at line 64 of file logger.cpp.

min_level_

std::atomic<log_level> kcenon::logger::logger::impl::min_level_

Definition at line 65 of file logger.cpp.

named_writers_

std::unordered_map<std::string, std::shared_ptr<log_writer_interface> > kcenon::logger::logger::impl::named_writers_

Definition at line 67 of file logger.cpp.

Referenced by dispatch_to_writers().

router_

std::unique_ptr<log_router> kcenon::logger::logger::impl::router_

Definition at line 73 of file logger.cpp.

Referenced by dispatch_to_writers().

router_mutex_

std::shared_mutex kcenon::logger::logger::impl::router_mutex_

mutable

Definition at line 74 of file logger.cpp.

Referenced by dispatch_to_writers().

running_

bool kcenon::logger::logger::impl::running_

Definition at line 63 of file logger.cpp.

sampler_

std::unique_ptr<sampling::log_sampler> kcenon::logger::logger::impl::sampler_

Definition at line 86 of file logger.cpp.

sampler_mutex_

std::shared_mutex kcenon::logger::logger::impl::sampler_mutex_

mutable

Definition at line 87 of file logger.cpp.

writers_

std::vector<std::shared_ptr<log_writer_interface> > kcenon::logger::logger::impl::writers_

Definition at line 66 of file logger.cpp.

Referenced by dispatch_to_writers(), and impl().

writers_mutex_

std::shared_mutex kcenon::logger::logger::impl::writers_mutex_

Definition at line 68 of file logger.cpp.

Referenced by dispatch_to_writers().

---

The documentation for this class was generated from the following file:

• src/core/logger.cpp