Basic monitoring implementation. More...

#include <basic_monitor.h>

Inheritance diagram for kcenon::logger::basic_monitor:

Collaboration diagram for kcenon::logger::basic_monitor:

Public Member Functions
	basic_monitor ()
	Constructor.

	~basic_monitor () override=default
	Destructor.

result< monitoring_data >	collect_metrics () const override
	Collect current metrics.

result< health_check_result >	check_health () const override
	Perform health check.

common::VoidResult	reset_metrics () override
	Reset all metrics.

common::VoidResult	set_enabled (bool enable) override
	Enable or disable monitoring.

bool	is_enabled () const override
	Check if monitoring is enabled.

std::string	get_backend_name () const override
	Get backend name.

void	increment_counter (const std::string &name, double value=1.0) override
	Increment a counter.

void	update_gauge (const std::string &name, double value) override
	Update a gauge.

void	record_histogram (const std::string &name, double value) override
	Record a histogram value.

void	add_health_issue (const std::string &issue)
	Add a health issue.

void	clear_health_issues ()
	Clear health issues.

Public Member Functions inherited from kcenon::logger::monitoring_interface
virtual	~monitoring_interface ()=default
	Virtual destructor.

Private Attributes
std::mutex	mutex_

std::atomic< bool >	enabled_ {true}

std::atomic< uint64_t >	messages_logged_ {0}

std::atomic< uint64_t >	messages_dropped_ {0}

std::atomic< uint64_t >	errors_encountered_ {0}

std::atomic< uint64_t >	writers_failed_ {0}

std::atomic< uint64_t >	total_processing_time_us_ {0}

std::atomic< uint64_t >	max_processing_time_us_ {0}

std::atomic< uint64_t >	min_processing_time_us_ {UINT64_MAX}

std::atomic< size_t >	buffer_usage_bytes_ {0}

std::atomic< size_t >	max_buffer_usage_bytes_ {0}

std::atomic< size_t >	queue_size_ {0}

std::atomic< size_t >	max_queue_size_ {0}

std::vector< std::string >	health_issues_

std::unordered_map< std::string, std::atomic< double > >	counters_

std::unordered_map< std::string, std::atomic< double > >	gauges_

std::unordered_map< std::string, std::vector< double > >	histograms_

std::chrono::system_clock::time_point	start_time_

Detailed Description

Basic monitoring implementation.

This implementation provides essential monitoring capabilities with minimal overhead and no external dependencies.

Definition at line 33 of file basic_monitor.h.

Constructor & Destructor Documentation

◆ basic_monitor()

kcenon::logger::basic_monitor::basic_monitor ( )

inline

Constructor.

Definition at line 70 of file basic_monitor.h.

70: start_time_(std::chrono::system_clock::now()) {}

kcenon::logger::basic_monitor::start_time_

std::chrono::system_clock::time_point start_time_

Definition basic_monitor.h:64

◆ ~basic_monitor()

kcenon::logger::basic_monitor::~basic_monitor ( )

overridedefault

Destructor.

Member Function Documentation

◆ add_health_issue()

void kcenon::logger::basic_monitor::add_health_issue ( const std::string & issue )

inline

Add a health issue.

Parameters

issue Issue description

Definition at line 413 of file basic_monitor.h.

                                                  {
        std::lock_guard<std::mutex> lock(mutex_);
        health_issues_.push_back(issue);
    }

References health_issues_, and mutex_.

◆ check_health()

result< health_check_result > kcenon::logger::basic_monitor::check_health ( ) const

inlineoverridevirtual

Perform health check.

Returns: Result containing health check result

Implements kcenon::logger::monitoring_interface.

Definition at line 187 of file basic_monitor.h.

                                                              {
        health_check_result result;
        
        // Check error rate
        uint64_t errors = errors_encountered_.load();
        uint64_t messages = messages_logged_.load();
        if (messages > 0) {
            double error_rate = static_cast<double>(errors) / messages;
            if (error_rate > 0.1) {  // More than 10% error rate
                result.add_issue("High error rate: " + 
                               std::to_string(error_rate * 100) + "%");
                result.set_status(health_status::unhealthy);
            } else if (error_rate > 0.05) {  // More than 5% error rate
                result.add_issue("Elevated error rate: " + 
                               std::to_string(error_rate * 100) + "%");
                result.set_status(health_status::degraded);
            }
        }
        
        // Check dropped messages
        uint64_t dropped = messages_dropped_.load();
        if (dropped > 0) {
            if (messages > 0) {
                double drop_rate = static_cast<double>(dropped) / messages;
                if (drop_rate > 0.01) {  // More than 1% drop rate
                    result.add_issue("Messages being dropped: " + 
                                   std::to_string(dropped) + " total");
                    if (result.get_status() == health_status::healthy) {
                        result.set_status(health_status::degraded);
                    }
                }
            }
        }
        
        // Check writer failures
        uint64_t writer_failures = writers_failed_.load();
        if (writer_failures > 0) {
            result.add_issue("Writer failures detected: " + 
                           std::to_string(writer_failures));
            if (result.get_status() == health_status::healthy) {
                result.set_status(health_status::degraded);
            }
        }
        
        // Check queue size
        size_t queue_size = queue_size_.load();
        size_t max_queue = max_queue_size_.load();
        if (max_queue > 0 && queue_size > max_queue * 0.9) {
            result.add_issue("Queue near capacity: " + 
                           std::to_string(queue_size) + "/" + 
                           std::to_string(max_queue));
            if (result.get_status() == health_status::healthy) {
                result.set_status(health_status::degraded);
            }
        }
        
        // Add any custom health issues
        {
            std::lock_guard<std::mutex> lock(mutex_);
            for (const auto& issue : health_issues_) {
                result.add_issue(issue);
            }
        }
        
        // Set overall message
        if (result.is_healthy()) {
            result.set_message("All systems operational");
        } else {
            result.set_message("Issues detected - check details");
        }
        
        return result;
    }

References errors_encountered_, health_issues_, max_queue_size_, messages_dropped_, messages_logged_, mutex_, queue_size_, and writers_failed_.

◆ clear_health_issues()

void kcenon::logger::basic_monitor::clear_health_issues ( )

inline

Clear health issues.

Definition at line 421 of file basic_monitor.h.

                               {
        std::lock_guard<std::mutex> lock(mutex_);
        health_issues_.clear();
    }

References health_issues_, and mutex_.

◆ collect_metrics()

result< monitoring_data > kcenon::logger::basic_monitor::collect_metrics ( ) const

inlineoverridevirtual

Collect current metrics.

Returns: Result containing monitoring data

Implements kcenon::logger::monitoring_interface.

Definition at line 81 of file basic_monitor.h.

                                                             {
        if (!enabled_.load()) {
            return result<monitoring_data>{error_code::metrics_not_available,
                            "Monitoring is disabled"};
        }
        
        monitoring_data data;
        
        // Core metrics
        data.add_metric("messages_logged", 
                       static_cast<double>(messages_logged_.load()), 
                       metric_type::counter);
        data.add_metric("messages_dropped", 
                       static_cast<double>(messages_dropped_.load()), 
                       metric_type::counter);
        data.add_metric("errors_encountered", 
                       static_cast<double>(errors_encountered_.load()), 
                       metric_type::counter);
        data.add_metric("writers_failed", 
                       static_cast<double>(writers_failed_.load()), 
                       metric_type::counter);
        
        // Performance metrics
        uint64_t total_time = total_processing_time_us_.load();
        uint64_t messages = messages_logged_.load();
        if (messages > 0) {
            data.add_metric("avg_processing_time_us", 
                           static_cast<double>(total_time) / messages, 
                           metric_type::gauge);
        }
        data.add_metric("max_processing_time_us", 
                       static_cast<double>(max_processing_time_us_.load()), 
                       metric_type::gauge);
        
        uint64_t min_time = min_processing_time_us_.load();
        if (min_time != UINT64_MAX) {
            data.add_metric("min_processing_time_us", 
                           static_cast<double>(min_time), 
                           metric_type::gauge);
        }
        
        // Resource metrics
        data.add_metric("buffer_usage_bytes", 
                       static_cast<double>(buffer_usage_bytes_.load()), 
                       metric_type::gauge);
        data.add_metric("max_buffer_usage_bytes", 
                       static_cast<double>(max_buffer_usage_bytes_.load()), 
                       metric_type::gauge);
        data.add_metric("queue_size", 
                       static_cast<double>(queue_size_.load()), 
                       metric_type::gauge);
        data.add_metric("max_queue_size", 
                       static_cast<double>(max_queue_size_.load()), 
                       metric_type::gauge);
        
        // Uptime
        auto now = std::chrono::system_clock::now();
        auto uptime = std::chrono::duration_cast<std::chrono::seconds>(
            now - start_time_).count();
        data.add_metric("uptime_seconds", 
                       static_cast<double>(uptime), 
                       metric_type::gauge);
        
        // Add custom counters and gauges
        {
            std::lock_guard<std::mutex> lock(mutex_);
            
            for (const auto& [name, value] : counters_) {
                data.add_metric(name, value.load(), metric_type::counter);
            }
            
            for (const auto& [name, value] : gauges_) {
                data.add_metric(name, value.load(), metric_type::gauge);
            }
            
            // Calculate histogram summaries
            for (const auto& [name, values] : histograms_) {
                if (!values.empty()) {
                    double sum = 0;
                    double min_val = values[0];
                    double max_val = values[0];
                    
                    for (double v : values) {
                        sum += v;
                        min_val = std::min(min_val, v);
                        max_val = std::max(max_val, v);
                    }
                    
                    double avg = sum / values.size();
                    data.add_metric(name + "_avg", avg, metric_type::summary);
                    data.add_metric(name + "_min", min_val, metric_type::summary);
                    data.add_metric(name + "_max", max_val, metric_type::summary);
                    data.add_metric(name + "_count", 
                                   static_cast<double>(values.size()), 
                                   metric_type::summary);
                }
            }
        }
        
        return data;
    }

References kcenon::logger::monitoring_data::add_metric(), buffer_usage_bytes_, kcenon::logger::counter, counters_, enabled_, errors_encountered_, kcenon::logger::gauge, gauges_, histograms_, max_buffer_usage_bytes_, max_processing_time_us_, max_queue_size_, messages_dropped_, messages_logged_, kcenon::logger::metrics_not_available, min_processing_time_us_, mutex_, queue_size_, start_time_, kcenon::logger::summary, total_processing_time_us_, and writers_failed_.

Here is the call graph for this function:

◆ get_backend_name()

std::string kcenon::logger::basic_monitor::get_backend_name ( ) const

inlineoverridevirtual

Get backend name.

Returns: "basic" for this implementation

Implements kcenon::logger::monitoring_interface.

Definition at line 315 of file basic_monitor.h.

                                                {
        return "basic";
    }

◆ increment_counter()

void kcenon::logger::basic_monitor::increment_counter	(	const std::string &	name,
		double	value = 1.0 )

inlineoverridevirtual

Increment a counter.

Parameters

name	Counter name
value	Increment value

Implements kcenon::logger::monitoring_interface.

Definition at line 324 of file basic_monitor.h.

                                                                               {
        if (!enabled_.load()) return;
        
        if (name == "messages_logged") {
            messages_logged_ += static_cast<uint64_t>(value);
        } else if (name == "messages_dropped") {
            messages_dropped_ += static_cast<uint64_t>(value);
        } else if (name == "errors_encountered") {
            errors_encountered_ += static_cast<uint64_t>(value);
        } else if (name == "writers_failed") {
            writers_failed_ += static_cast<uint64_t>(value);
        } else {
            std::lock_guard<std::mutex> lock(mutex_);
            counters_[name] += value;
        }
    }

References counters_, enabled_, errors_encountered_, messages_dropped_, messages_logged_, mutex_, and writers_failed_.

◆ is_enabled()

bool kcenon::logger::basic_monitor::is_enabled ( ) const

inlineoverridevirtual

Check if monitoring is enabled.

Returns: true if enabled

Implements kcenon::logger::monitoring_interface.

Definition at line 307 of file basic_monitor.h.

                                     {
        return enabled_.load();
    }

References enabled_.

◆ record_histogram()

void kcenon::logger::basic_monitor::record_histogram	(	const std::string &	name,
		double	value )

inlineoverridevirtual

Record a histogram value.

Parameters

name	Histogram name
value	Value to record

Implements kcenon::logger::monitoring_interface.

Definition at line 376 of file basic_monitor.h.

                                                                        {
        if (!enabled_.load()) return;
        
        if (name == "processing_time_us") {
            uint64_t us_value = static_cast<uint64_t>(value);
            total_processing_time_us_ += us_value;
            
            // Update max
            uint64_t max_val = max_processing_time_us_.load();
            while (us_value > max_val && 
                   !max_processing_time_us_.compare_exchange_weak(max_val, us_value)) {
                // Loop until successful
            }
            
            // Update min
            uint64_t min_val = min_processing_time_us_.load();
            while (us_value < min_val && 
                   !min_processing_time_us_.compare_exchange_weak(min_val, us_value)) {
                // Loop until successful
            }
        } else {
            std::lock_guard<std::mutex> lock(mutex_);
            histograms_[name].push_back(value);
            
            // Limit histogram size to prevent unbounded growth
            if (histograms_[name].size() > 10000) {
                // Keep only recent values
                histograms_[name].erase(histograms_[name].begin(),
                                       histograms_[name].begin() + 5000);
            }
        }
    }

References enabled_, histograms_, max_processing_time_us_, min_processing_time_us_, mutex_, kcenon::logger::size, and total_processing_time_us_.

◆ reset_metrics()

common::VoidResult kcenon::logger::basic_monitor::reset_metrics ( )

inlineoverridevirtual

Reset all metrics.

Returns: Result indicating success

Implements kcenon::logger::monitoring_interface.

Definition at line 265 of file basic_monitor.h.

                                              {
        messages_logged_ = 0;
        messages_dropped_ = 0;
        errors_encountered_ = 0;
        writers_failed_ = 0;
 
        total_processing_time_us_ = 0;
        max_processing_time_us_ = 0;
        min_processing_time_us_ = UINT64_MAX;
 
        buffer_usage_bytes_ = 0;
        max_buffer_usage_bytes_ = 0;
        queue_size_ = 0;
        max_queue_size_ = 0;
 
        {
            std::lock_guard<std::mutex> lock(mutex_);
            counters_.clear();
            gauges_.clear();
            histograms_.clear();
            health_issues_.clear();
        }
 
        start_time_ = std::chrono::system_clock::now();
 
        return common::ok();
    }

References buffer_usage_bytes_, counters_, errors_encountered_, gauges_, health_issues_, histograms_, max_buffer_usage_bytes_, max_processing_time_us_, max_queue_size_, messages_dropped_, messages_logged_, min_processing_time_us_, mutex_, kcenon::common::ok(), queue_size_, start_time_, total_processing_time_us_, and writers_failed_.

Here is the call graph for this function:

◆ set_enabled()

common::VoidResult kcenon::logger::basic_monitor::set_enabled ( bool enable )

inlineoverridevirtual

Enable or disable monitoring.

Parameters

enable true to enable

Returns: Result indicating success

Implements kcenon::logger::monitoring_interface.

Definition at line 298 of file basic_monitor.h.

                                                       {
        enabled_ = enable;
        return common::ok();
    }

References enabled_, and kcenon::common::ok().

Here is the call graph for this function:

◆ update_gauge()

void kcenon::logger::basic_monitor::update_gauge	(	const std::string &	name,
		double	value )

inlineoverridevirtual

Update a gauge.

Parameters

name	Gauge name
value	New value

Implements kcenon::logger::monitoring_interface.

Definition at line 346 of file basic_monitor.h.

                                                                    {
        if (!enabled_.load()) return;
        
        if (name == "buffer_usage_bytes") {
            buffer_usage_bytes_ = static_cast<size_t>(value);
            size_t max_val = max_buffer_usage_bytes_.load();
            while (value > max_val && 
                   !max_buffer_usage_bytes_.compare_exchange_weak(max_val, 
                                                                  static_cast<size_t>(value))) {
                // Loop until successful
            }
        } else if (name == "queue_size") {
            queue_size_ = static_cast<size_t>(value);
            size_t max_val = max_queue_size_.load();
            while (value > max_val && 
                   !max_queue_size_.compare_exchange_weak(max_val, 
                                                         static_cast<size_t>(value))) {
                // Loop until successful
            }
        } else {
            std::lock_guard<std::mutex> lock(mutex_);
            gauges_[name] = value;
        }
    }

References buffer_usage_bytes_, enabled_, gauges_, max_buffer_usage_bytes_, max_queue_size_, mutex_, and queue_size_.

Member Data Documentation

◆ buffer_usage_bytes_

std::atomic<size_t> kcenon::logger::basic_monitor::buffer_usage_bytes_ {0}

private

Definition at line 50 of file basic_monitor.h.

50{0};

Referenced by collect_metrics(), reset_metrics(), and update_gauge().

◆ counters_

std::unordered_map<std::string, std::atomic<double> > kcenon::logger::basic_monitor::counters_

mutableprivate

Definition at line 59 of file basic_monitor.h.

Referenced by collect_metrics(), increment_counter(), and reset_metrics().

◆ enabled_

std::atomic<bool> kcenon::logger::basic_monitor::enabled_ {true}

private

Definition at line 36 of file basic_monitor.h.

36{true};

Referenced by collect_metrics(), increment_counter(), is_enabled(), record_histogram(), set_enabled(), and update_gauge().

◆ errors_encountered_

std::atomic<uint64_t> kcenon::logger::basic_monitor::errors_encountered_ {0}

private

Definition at line 41 of file basic_monitor.h.

41{0};

Referenced by check_health(), collect_metrics(), increment_counter(), and reset_metrics().

◆ gauges_

std::unordered_map<std::string, std::atomic<double> > kcenon::logger::basic_monitor::gauges_

mutableprivate

Definition at line 60 of file basic_monitor.h.

Referenced by collect_metrics(), reset_metrics(), and update_gauge().

◆ health_issues_

std::vector<std::string> kcenon::logger::basic_monitor::health_issues_

mutableprivate

Definition at line 56 of file basic_monitor.h.

Referenced by add_health_issue(), check_health(), clear_health_issues(), and reset_metrics().

◆ histograms_

std::unordered_map<std::string, std::vector<double> > kcenon::logger::basic_monitor::histograms_

mutableprivate

Definition at line 61 of file basic_monitor.h.

Referenced by collect_metrics(), record_histogram(), and reset_metrics().

◆ max_buffer_usage_bytes_

std::atomic<size_t> kcenon::logger::basic_monitor::max_buffer_usage_bytes_ {0}

private

Definition at line 51 of file basic_monitor.h.

51{0};

Referenced by collect_metrics(), reset_metrics(), and update_gauge().

◆ max_processing_time_us_

std::atomic<uint64_t> kcenon::logger::basic_monitor::max_processing_time_us_ {0}

private

Definition at line 46 of file basic_monitor.h.

46{0};

Referenced by collect_metrics(), record_histogram(), and reset_metrics().

◆ max_queue_size_

std::atomic<size_t> kcenon::logger::basic_monitor::max_queue_size_ {0}

private

Definition at line 53 of file basic_monitor.h.

53{0};

Referenced by check_health(), collect_metrics(), reset_metrics(), and update_gauge().

◆ messages_dropped_

std::atomic<uint64_t> kcenon::logger::basic_monitor::messages_dropped_ {0}

private

Definition at line 40 of file basic_monitor.h.

40{0};

Referenced by check_health(), collect_metrics(), increment_counter(), and reset_metrics().

◆ messages_logged_

std::atomic<uint64_t> kcenon::logger::basic_monitor::messages_logged_ {0}

private

Definition at line 39 of file basic_monitor.h.

39{0};

Referenced by check_health(), collect_metrics(), increment_counter(), and reset_metrics().

◆ min_processing_time_us_

std::atomic<uint64_t> kcenon::logger::basic_monitor::min_processing_time_us_ {UINT64_MAX}

private

Definition at line 47 of file basic_monitor.h.

47{UINT64_MAX};

Referenced by collect_metrics(), record_histogram(), and reset_metrics().

◆ mutex_

std::mutex kcenon::logger::basic_monitor::mutex_

mutableprivate

Definition at line 35 of file basic_monitor.h.

Referenced by add_health_issue(), check_health(), clear_health_issues(), collect_metrics(), increment_counter(), record_histogram(), reset_metrics(), and update_gauge().

◆ queue_size_

std::atomic<size_t> kcenon::logger::basic_monitor::queue_size_ {0}

private

Definition at line 52 of file basic_monitor.h.

52{0};

Referenced by check_health(), collect_metrics(), reset_metrics(), and update_gauge().

◆ start_time_

std::chrono::system_clock::time_point kcenon::logger::basic_monitor::start_time_

private

Definition at line 64 of file basic_monitor.h.

Referenced by collect_metrics(), and reset_metrics().

◆ total_processing_time_us_

std::atomic<uint64_t> kcenon::logger::basic_monitor::total_processing_time_us_ {0}

private

Definition at line 45 of file basic_monitor.h.

45{0};

Referenced by collect_metrics(), record_histogram(), and reset_metrics().

◆ writers_failed_

std::atomic<uint64_t> kcenon::logger::basic_monitor::writers_failed_ {0}

private

Definition at line 42 of file basic_monitor.h.

42{0};

Referenced by check_health(), collect_metrics(), increment_counter(), and reset_metrics().

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

src/impl/monitoring/basic_monitor.h

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ basic_monitor()

◆ ~basic_monitor()

Member Function Documentation

◆ add_health_issue()

◆ check_health()

◆ clear_health_issues()

◆ collect_metrics()

◆ get_backend_name()

◆ increment_counter()

◆ is_enabled()

◆ record_histogram()

◆ reset_metrics()

◆ set_enabled()

◆ update_gauge()

Member Data Documentation

◆ buffer_usage_bytes_

◆ counters_

◆ enabled_

◆ errors_encountered_

◆ gauges_

◆ health_issues_

◆ histograms_

◆ max_buffer_usage_bytes_

◆ max_processing_time_us_

◆ max_queue_size_

◆ messages_dropped_

◆ messages_logged_

◆ min_processing_time_us_

◆ mutex_

◆ queue_size_

◆ start_time_

◆ total_processing_time_us_

◆ writers_failed_