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

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

Public Member Functions
	impl (std::size_t buffer_size, std::size_t batch_size)
	~impl ()
bool	enqueue (log_level level, const std::string &message, const std::string &file, int line, const std::string &function, const std::chrono::system_clock::time_point &timestamp)
void	add_writer (std::shared_ptr< log_writer_interface > writer)
void	clear_writers ()
void	start ()
void	stop ()
void	flush ()
std::pair< std::size_t, std::size_t >	get_queue_metrics () const

Private Member Functions
void	drain_queue ()
void	flush_writers ()
void	write_to_all (const log_entry &entry)

Private Attributes
std::shared_ptr< log_collector_shared_state >	state_
std::unique_ptr< log_collector_jthread_worker >	worker_
std::atomic< std::uint64_t >	dropped_messages_ {0}

Detailed Description

Definition at line 250 of file log_collector.cpp.

Constructor & Destructor Documentation

impl()

kcenon::logger::log_collector::impl::impl ( std::size_t buffer_size, std::size_t batch_size )

inlineexplicit

Definition at line 252 of file log_collector.cpp.

        : state_(std::make_shared<log_collector_shared_state>(buffer_size, batch_size))
        , worker_(std::make_unique<log_collector_jthread_worker>(state_)) {
    }

~impl()

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

inline

Definition at line 257 of file log_collector.cpp.

            {
        stop();
    }

References stop().

Here is the call graph for this function:

Member Function Documentation

add_writer()

void kcenon::logger::log_collector::impl::add_writer ( std::shared_ptr< log_writer_interface > writer )

inline

Definition at line 299 of file log_collector.cpp.

                                                                {
        if (!writer) {
            return;
        }
        std::lock_guard<std::mutex> lock(state_->writers_mutex);
        state_->writers.push_back(writer);
    }

References state_.

clear_writers()

void kcenon::logger::log_collector::impl::clear_writers ( )

inline

Definition at line 307 of file log_collector.cpp.

                         {
        std::lock_guard<std::mutex> lock(state_->writers_mutex);
        state_->writers.clear();
    }

References state_.

drain_queue()

void kcenon::logger::log_collector::impl::drain_queue ( )

inlineprivate

Definition at line 354 of file log_collector.cpp.

                       {
        std::queue<log_entry> remaining;
        {
            std::lock_guard<std::mutex> lock(state_->queue_mutex);
            std::swap(remaining, state_->queue);
        }
 
        // Process remaining entries
        while (!remaining.empty()) {
            auto entry = std::move(remaining.front());
            remaining.pop();
            write_to_all(entry);
        }
    }

References state_, and write_to_all().

Referenced by stop().

Here is the call graph for this function:

Here is the caller graph for this function:

enqueue()

bool kcenon::logger::log_collector::impl::enqueue ( log_level level, const std::string & message, const std::string & file, int line, const std::string & function, const std::chrono::system_clock::time_point & timestamp )

inline

Definition at line 261 of file log_collector.cpp.

                                                                   {
        {
            std::lock_guard<std::mutex> lock(state_->queue_mutex);
 
            // Check if queue is full
            if (state_->queue.size() >= state_->buffer_size) {
                // Track dropped message
                std::uint64_t dropped = dropped_messages_.fetch_add(1, std::memory_order_relaxed) + 1;
 
                // Log warning periodically (every 100 dropped messages) to avoid spam
                if (dropped % 100 == 1) {
                    std::fprintf(stderr, "[WARNING] Log queue full: %llu messages dropped total\n",
                               static_cast<unsigned long long>(dropped));
                }
 
                return false;
            }
 
            // Create log_entry with optional source location
            log_entry entry(level, message, timestamp);
            if (!file.empty() || line != 0 || !function.empty()) {
                entry.location = source_location{file, line, function};
            }
            state_->queue.push(std::move(entry));
        }
 
        // Notify worker thread
        if (worker_) {
            worker_->notify_work();
        }
        return true;
    }

References dropped_messages_, kcenon::logger::log_entry::location, state_, and worker_.

flush()

void kcenon::logger::log_collector::impl::flush ( )

inline

Definition at line 331 of file log_collector.cpp.

                 {
        // Wait for queue to be empty
        while (true) {
            {
                std::lock_guard<std::mutex> lock(state_->queue_mutex);
                if (state_->queue.empty()) {
                    break;
                }
            }
            // Brief yield to allow worker to process
            std::this_thread::sleep_for(std::chrono::microseconds(100));
        }
 
        // Flush all writers
        flush_writers();
    }

References flush_writers(), and state_.

Here is the call graph for this function:

flush_writers()

void kcenon::logger::log_collector::impl::flush_writers ( )

inlineprivate

Definition at line 369 of file log_collector.cpp.

                         {
        std::vector<std::shared_ptr<log_writer_interface>> writers_snapshot;
        {
            std::lock_guard<std::mutex> lock(state_->writers_mutex);
            writers_snapshot.reserve(state_->writers.size());
            for (auto& weak_writer : state_->writers) {
                if (auto writer = weak_writer.lock()) {
                    writers_snapshot.push_back(writer);
                }
            }
        }
 
        for (auto& writer : writers_snapshot) {
            try {
                writer->flush();
            } catch (...) {
                // Swallow exceptions during flush
            }
        }
    }

References state_.

Referenced by flush(), and stop().

Here is the caller graph for this function:

get_queue_metrics()

std::pair< std::size_t, std::size_t > kcenon::logger::log_collector::impl::get_queue_metrics ( ) const

inlinenodiscard

Definition at line 348 of file log_collector.cpp.

                                                                          {
        std::lock_guard<std::mutex> lock(state_->queue_mutex);
        return {state_->queue.size(), state_->buffer_size};
    }

References state_.

start()

void kcenon::logger::log_collector::impl::start ( )

inline

Definition at line 312 of file log_collector.cpp.

                 {
        if (worker_) {
            worker_->start();
        }
    }

References worker_.

stop()

void kcenon::logger::log_collector::impl::stop ( )

inline

Definition at line 318 of file log_collector.cpp.

                {
        // Stop the worker thread first
        if (worker_) {
            worker_->stop();
        }
 
        // Drain remaining entries
        drain_queue();
 
        // Flush all writers
        flush_writers();
    }

References drain_queue(), flush_writers(), and worker_.

Referenced by ~impl().

Here is the call graph for this function:

Here is the caller graph for this function:

write_to_all()

void kcenon::logger::log_collector::impl::write_to_all ( const log_entry & entry )

inlineprivate

Definition at line 390 of file log_collector.cpp.

                                              {
        // Snapshot writers under lock
        std::vector<std::shared_ptr<log_writer_interface>> writers_snapshot;
        {
            std::lock_guard<std::mutex> lock(state_->writers_mutex);
            writers_snapshot.reserve(state_->writers.size());
            for (auto& weak_writer : state_->writers) {
                if (auto writer = weak_writer.lock()) {
                    writers_snapshot.push_back(writer);
                }
            }
        }
 
        // Write to all writers without holding mutex
        for (auto& writer : writers_snapshot) {
            try {
                writer->write(entry);
            } catch (...) {
                // Swallow exceptions to prevent issues
            }
        }
    }

References state_.

Referenced by drain_queue().

Here is the caller graph for this function:

Member Data Documentation

dropped_messages_

std::atomic<std::uint64_t> kcenon::logger::log_collector::impl::dropped_messages_ {0}

private

Definition at line 416 of file log_collector.cpp.

{0};

Referenced by enqueue().

state_

std::shared_ptr<log_collector_shared_state> kcenon::logger::log_collector::impl::state_

private

Definition at line 414 of file log_collector.cpp.

Referenced by add_writer(), clear_writers(), drain_queue(), enqueue(), flush(), flush_writers(), get_queue_metrics(), and write_to_all().

worker_

std::unique_ptr<log_collector_jthread_worker> kcenon::logger::log_collector::impl::worker_

private

Definition at line 415 of file log_collector.cpp.

Referenced by enqueue(), start(), and stop().

---

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

• src/core/log_collector.cpp