kcenon::pacs::integration::monitoring_adapter::impl Class Reference

Collaboration diagram for kcenon::pacs::integration::monitoring_adapter::impl:

Public Member Functions
	impl ()=default
	~impl ()
void	initialize (const monitoring_config &config)
void	shutdown ()
auto	is_initialized () const noexcept -> bool
void	increment_counter (std::string_view name, std::int64_t value)
void	set_gauge (std::string_view name, double value)
void	record_histogram (std::string_view name, double value)
void	record_timing (std::string_view name, std::chrono::nanoseconds duration)
void	record_c_store (std::chrono::nanoseconds duration, std::size_t bytes, bool success)
void	record_c_find (std::chrono::nanoseconds duration, std::size_t matches, query_level level)
void	record_association (const std::string &calling_ae, bool established)
void	update_storage_stats (std::size_t total_instances, std::size_t total_bytes)
auto	get_health () -> monitoring_adapter::health_status
void	register_health_check (std::string_view component, std::function< bool()> check)
void	unregister_health_check (std::string_view component)
auto	get_config () const -> const monitoring_config &

Private Attributes
std::mutex	mutex_
std::mutex	counters_mutex_
std::mutex	gauges_mutex_
std::shared_mutex	health_checks_mutex_
std::atomic< bool >	initialized_ {false}
monitoring_config	config_
std::unordered_map< std::string, std::int64_t >	counters_
std::unordered_map< std::string, double >	gauges_
std::unordered_map< std::string, std::function< bool()> >	health_checks_

Detailed Description

Definition at line 166 of file monitoring_adapter.cpp.

Constructor & Destructor Documentation

impl()

kcenon::pacs::integration::monitoring_adapter::impl::impl ( )

default

~impl()

kcenon::pacs::integration::monitoring_adapter::impl::~impl ( )

inline

Definition at line 169 of file monitoring_adapter.cpp.

{ shutdown(); }

Member Function Documentation

get_config()

auto kcenon::pacs::integration::monitoring_adapter::impl::get_config ( ) const -> const monitoring_config&

inlinenodiscard

Definition at line 372 of file monitoring_adapter.cpp.

                                                                      {
        return config_;
    }

Referenced by kcenon::pacs::integration::monitoring_adapter::get_config().

Here is the caller graph for this function:

get_health()

auto kcenon::pacs::integration::monitoring_adapter::impl::get_health ( ) -> monitoring_adapter::health_status

inlinenodiscard

Definition at line 337 of file monitoring_adapter.cpp.

                                                                       {
        monitoring_adapter::health_status status;
        status.healthy = true;
        status.status = "healthy";
 
        std::shared_lock lock(health_checks_mutex_);
        for (const auto& [component, check] : health_checks_) {
            try {
                bool component_healthy = check();
                status.components[component] = component_healthy ? "healthy" : "unhealthy";
                if (!component_healthy) {
                    status.healthy = false;
                    status.status = "degraded";
                }
            } catch (const std::exception& e) {
                status.components[component] = std::string("error: ") + e.what();
                status.healthy = false;
                status.status = "degraded";
            }
        }
 
        return status;
    }

Referenced by kcenon::pacs::integration::monitoring_adapter::get_health().

Here is the caller graph for this function:

increment_counter()

void kcenon::pacs::integration::monitoring_adapter::impl::increment_counter ( std::string_view name, std::int64_t value )

inline

Definition at line 226 of file monitoring_adapter.cpp.

                                                                  {
        if (!initialized_) return;
 
        std::lock_guard lock(counters_mutex_);
        counters_[std::string(name)] += value;
    }

References name.

Referenced by kcenon::pacs::integration::monitoring_adapter::increment_counter().

Here is the caller graph for this function:

initialize()

void kcenon::pacs::integration::monitoring_adapter::impl::initialize ( const monitoring_config & config )

inline

Definition at line 171 of file monitoring_adapter.cpp.

                                                     {
        std::lock_guard lock(mutex_);
 
        if (initialized_) {
            return;
        }
 
        config_ = config;
 
        // Initialize performance monitor
        if (config.enable_metrics) {
            auto& monitor = kcenon::monitoring::global_performance_monitor();
            monitor.set_enabled(true);
            monitor.get_profiler().set_max_samples(config.max_samples_per_operation);
 
            auto init_result = monitor.initialize();
            if (init_result.is_err()) {
                // Log warning but continue - metrics will still work locally
            }
        }
 
        // Initialize counters and gauges to zero
        counters_[metrics::c_store_total] = 0;
        counters_[metrics::c_store_success] = 0;
        counters_[metrics::c_store_failure] = 0;
        counters_[metrics::c_store_bytes_total] = 0;
        counters_[metrics::c_find_total] = 0;
        counters_[metrics::associations_total] = 0;
 
        gauges_[metrics::associations_active] = 0.0;
        gauges_[metrics::storage_instances] = 0.0;
        gauges_[metrics::storage_bytes] = 0.0;
 
        initialized_ = true;
    }

References kcenon::pacs::integration::monitoring_config::enable_metrics, and kcenon::pacs::integration::monitoring_config::max_samples_per_operation.

Referenced by kcenon::pacs::integration::monitoring_adapter::initialize().

Here is the caller graph for this function:

is_initialized()

auto kcenon::pacs::integration::monitoring_adapter::impl::is_initialized ( ) const -> bool

inlinenodiscardnoexcept

Definition at line 222 of file monitoring_adapter.cpp.

                                                               {
        return initialized_.load();
    }

Referenced by kcenon::pacs::integration::monitoring_adapter::is_initialized().

Here is the caller graph for this function:

record_association()

void kcenon::pacs::integration::monitoring_adapter::impl::record_association ( const std::string & calling_ae, bool established )

inline

Definition at line 307 of file monitoring_adapter.cpp.

                                                                           {
        if (!initialized_) return;
 
        // Update counters and gauges
        {
            std::lock_guard lock(counters_mutex_);
            counters_[metrics::associations_total]++;
        }
 
        {
            std::lock_guard lock(gauges_mutex_);
            if (established) {
                gauges_[metrics::associations_active]++;
            } else {
                gauges_[metrics::associations_active] =
                    (std::max)(0.0, gauges_[metrics::associations_active] - 1);
            }
        }
 
        (void)calling_ae;  // Used for logging/tagging
    }

Referenced by kcenon::pacs::integration::monitoring_adapter::record_association().

Here is the caller graph for this function:

record_c_find()

void kcenon::pacs::integration::monitoring_adapter::impl::record_c_find ( std::chrono::nanoseconds duration, std::size_t matches, query_level level )

inline

Definition at line 281 of file monitoring_adapter.cpp.

                                          {
        if (!initialized_) return;
 
        // Update counters
        {
            std::lock_guard lock(counters_mutex_);
            counters_[metrics::c_find_total]++;
        }
 
        // Record timing and matches histogram
        if (config_.enable_metrics) {
            auto& profiler =
                kcenon::monitoring::global_performance_monitor().get_profiler();
            profiler.record_sample(metrics::c_find_duration, duration, true);
 
            // Record matches as a timing metric (converting to nanoseconds)
            auto matches_as_duration =
                std::chrono::nanoseconds(static_cast<std::int64_t>(matches));
            profiler.record_sample(metrics::c_find_matches, matches_as_duration, true);
        }
 
        (void)level;  // Level used for tagging in tracing
    }

Referenced by kcenon::pacs::integration::monitoring_adapter::record_c_find().

Here is the caller graph for this function:

record_c_store()

void kcenon::pacs::integration::monitoring_adapter::impl::record_c_store ( std::chrono::nanoseconds duration, std::size_t bytes, bool success )

inline

Definition at line 256 of file monitoring_adapter.cpp.

                                      {
        if (!initialized_) return;
 
        // Update counters
        {
            std::lock_guard lock(counters_mutex_);
            counters_[metrics::c_store_total]++;
            if (success) {
                counters_[metrics::c_store_success]++;
            } else {
                counters_[metrics::c_store_failure]++;
            }
            counters_[metrics::c_store_bytes_total] += static_cast<std::int64_t>(bytes);
        }
 
        // Record timing histogram
        if (config_.enable_metrics) {
            auto& profiler =
                kcenon::monitoring::global_performance_monitor().get_profiler();
            profiler.record_sample(metrics::c_store_duration, duration, success);
        }
    }

References kcenon::pacs::integration::success.

Referenced by kcenon::pacs::integration::monitoring_adapter::record_c_store().

Here is the caller graph for this function:

record_histogram()

void kcenon::pacs::integration::monitoring_adapter::impl::record_histogram ( std::string_view name, double value )

inline

Definition at line 240 of file monitoring_adapter.cpp.

                                                             {
        if (!initialized_ || !config_.enable_metrics) return;
 
        auto& profiler = kcenon::monitoring::global_performance_monitor().get_profiler();
        // Convert double to nanoseconds for histogram recording
        auto duration = std::chrono::nanoseconds(static_cast<std::int64_t>(value * 1e9));
        profiler.record_sample(std::string(name), duration, true);
    }

References name.

Referenced by kcenon::pacs::integration::monitoring_adapter::record_histogram().

Here is the caller graph for this function:

record_timing()

void kcenon::pacs::integration::monitoring_adapter::impl::record_timing ( std::string_view name, std::chrono::nanoseconds duration )

inline

Definition at line 249 of file monitoring_adapter.cpp.

                                                                           {
        if (!initialized_ || !config_.enable_metrics) return;
 
        auto& profiler = kcenon::monitoring::global_performance_monitor().get_profiler();
        profiler.record_sample(std::string(name), duration, true);
    }

References name.

Referenced by kcenon::pacs::integration::monitoring_adapter::record_timing().

Here is the caller graph for this function:

register_health_check()

void kcenon::pacs::integration::monitoring_adapter::impl::register_health_check ( std::string_view component, std::function< bool()> check )

inline

Definition at line 361 of file monitoring_adapter.cpp.

                                                          {
        std::unique_lock lock(health_checks_mutex_);
        health_checks_[std::string(component)] = std::move(check);
    }

Referenced by kcenon::pacs::integration::monitoring_adapter::register_health_check().

Here is the caller graph for this function:

set_gauge()

void kcenon::pacs::integration::monitoring_adapter::impl::set_gauge ( std::string_view name, double value )

inline

Definition at line 233 of file monitoring_adapter.cpp.

                                                      {
        if (!initialized_) return;
 
        std::lock_guard lock(gauges_mutex_);
        gauges_[std::string(name)] = value;
    }

References name.

Referenced by kcenon::pacs::integration::monitoring_adapter::set_gauge().

Here is the caller graph for this function:

shutdown()

void kcenon::pacs::integration::monitoring_adapter::impl::shutdown ( )

inline

Definition at line 207 of file monitoring_adapter.cpp.

                    {
        std::lock_guard lock(mutex_);
 
        if (!initialized_) {
            return;
        }
 
        // Cleanup performance monitor
        auto& monitor = kcenon::monitoring::global_performance_monitor();
        auto cleanup_result = monitor.cleanup();
        (void)cleanup_result;  // Ignore cleanup errors during shutdown
 
        initialized_ = false;
    }

Referenced by kcenon::pacs::integration::monitoring_adapter::shutdown().

Here is the caller graph for this function:

unregister_health_check()

void kcenon::pacs::integration::monitoring_adapter::impl::unregister_health_check ( std::string_view component )

inline

Definition at line 367 of file monitoring_adapter.cpp.

                                                           {
        std::unique_lock lock(health_checks_mutex_);
        health_checks_.erase(std::string(component));
    }

Referenced by kcenon::pacs::integration::monitoring_adapter::unregister_health_check().

Here is the caller graph for this function:

update_storage_stats()

void kcenon::pacs::integration::monitoring_adapter::impl::update_storage_stats ( std::size_t total_instances, std::size_t total_bytes )

inline

Definition at line 329 of file monitoring_adapter.cpp.

                                                                                {
        if (!initialized_) return;
 
        std::lock_guard lock(gauges_mutex_);
        gauges_[metrics::storage_instances] = static_cast<double>(total_instances);
        gauges_[metrics::storage_bytes] = static_cast<double>(total_bytes);
    }

Referenced by kcenon::pacs::integration::monitoring_adapter::update_storage_stats().

Here is the caller graph for this function:

Member Data Documentation

config_

monitoring_config kcenon::pacs::integration::monitoring_adapter::impl::config_

private

Definition at line 383 of file monitoring_adapter.cpp.

counters_

std::unordered_map<std::string, std::int64_t> kcenon::pacs::integration::monitoring_adapter::impl::counters_

private

Definition at line 386 of file monitoring_adapter.cpp.

counters_mutex_

std::mutex kcenon::pacs::integration::monitoring_adapter::impl::counters_mutex_

mutableprivate

Definition at line 378 of file monitoring_adapter.cpp.

gauges_

std::unordered_map<std::string, double> kcenon::pacs::integration::monitoring_adapter::impl::gauges_

private

Definition at line 387 of file monitoring_adapter.cpp.

gauges_mutex_

std::mutex kcenon::pacs::integration::monitoring_adapter::impl::gauges_mutex_

mutableprivate

Definition at line 379 of file monitoring_adapter.cpp.

health_checks_

std::unordered_map<std::string, std::function<bool()> > kcenon::pacs::integration::monitoring_adapter::impl::health_checks_

private

Definition at line 388 of file monitoring_adapter.cpp.

health_checks_mutex_

std::shared_mutex kcenon::pacs::integration::monitoring_adapter::impl::health_checks_mutex_

mutableprivate

Definition at line 380 of file monitoring_adapter.cpp.

initialized_

std::atomic<bool> kcenon::pacs::integration::monitoring_adapter::impl::initialized_ {false}

private

Definition at line 382 of file monitoring_adapter.cpp.

{false};

mutex_

std::mutex kcenon::pacs::integration::monitoring_adapter::impl::mutex_

mutableprivate

Definition at line 377 of file monitoring_adapter.cpp.

---

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

• src/integration/monitoring_adapter.cpp