Unified PACS monitoring implementing IMonitor interface. More...

#include <pacs_monitor.h>

Collaboration diagram for kcenon::pacs::monitoring::pacs_monitor:

Public Member Functions
	pacs_monitor (const pacs_monitor_config &config={})
	Construct a new PACS monitor.

	~pacs_monitor ()=default
	Destructor.

	pacs_monitor (const pacs_monitor &)=delete

pacs_monitor &	operator= (const pacs_monitor &)=delete

	pacs_monitor (pacs_monitor &&)=delete

pacs_monitor &	operator= (pacs_monitor &&)=delete

void	record_metric (std::string_view name, double value)
	Record a metric value.

void	record_metric (std::string_view name, double value, const std::unordered_map< std::string, std::string > &tags)
	Record a metric with tags.

metrics_snapshot	get_metrics ()
	Get current metrics snapshot.

health_check_result	check_health ()
	Perform health check.

void	reset ()
	Reset all metrics.

std::string	to_prometheus () const
	Export all metrics in Prometheus text format.

std::string	to_json () const
	Export all metrics as JSON.

void	register_health_check (std::string_view component, std::function< bool()> check)
	Register a health check for a component.

void	unregister_health_check (std::string_view component)
	Unregister a health check.

const pacs_monitor_config &	get_config () const
	Get current configuration.

void	update_config (const pacs_monitor_config &config)
	Update configuration.

dicom_association_collector &	association_collector ()
	Get the association collector.

dicom_service_collector &	service_collector ()
	Get the service collector.

dicom_storage_collector &	storage_collector ()
	Get the storage collector.

dicom_metrics_collector &	unified_collector ()
	Get the unified CRTP-based metrics collector.

dicom_metrics_snapshot	get_unified_snapshot () const
	Get a snapshot from the unified collector.

Static Public Member Functions
static pacs_monitor &	global_monitor () noexcept
	Get the global singleton instance.

Private Member Functions
void	initialize_collectors ()

void	collect_all_metrics (metrics_snapshot &snapshot)

Private Attributes
pacs_monitor_config	config_

std::shared_mutex	config_mutex_

std::unique_ptr< dicom_association_collector >	association_collector_

std::unique_ptr< dicom_service_collector >	service_collector_

std::unique_ptr< dicom_storage_collector >	storage_collector_

std::unique_ptr< dicom_metrics_collector >	unified_collector_

std::mutex	custom_metrics_mutex_

std::vector< metric_value >	custom_metrics_

std::mutex	health_checks_mutex_

std::unordered_map< std::string, std::function< bool()> >	health_checks_

Detailed Description

Unified PACS monitoring implementing IMonitor interface.

This class provides a unified monitoring interface for the PACS system, integrating all DICOM-specific metric collectors and implementing the IMonitor interface from common_system.

Features:

DICOM association metrics (active, peak, success rate)
DIMSE service metrics (C-ECHO, C-STORE, C-FIND, C-MOVE, C-GET, N-*)
Storage metrics (bytes transferred, images stored/retrieved)
Object pool metrics (element, dataset, PDU buffer pools)
Health check integration
Prometheus-compatible metric export

Thread Safety: All public methods are thread-safe.

Definition at line 223 of file pacs_monitor.h.

Constructor & Destructor Documentation

◆ pacs_monitor() [1/3]

kcenon::pacs::monitoring::pacs_monitor::pacs_monitor ( const pacs_monitor_config & config = {} )

inlineexplicit

Construct a new PACS monitor.

Parameters

config Configuration options

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 408 of file pacs_monitor.h.

    : config_(config) {
    initialize_collectors();
}

References initialize_collectors().

Here is the call graph for this function:

◆ ~pacs_monitor()

kcenon::pacs::monitoring::pacs_monitor::~pacs_monitor ( )

default

Destructor.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

◆ pacs_monitor() [2/3]

kcenon::pacs::monitoring::pacs_monitor::pacs_monitor ( const pacs_monitor & )

delete

◆ pacs_monitor() [3/3]

kcenon::pacs::monitoring::pacs_monitor::pacs_monitor ( pacs_monitor && )

delete

Member Function Documentation

◆ association_collector()

dicom_association_collector & kcenon::pacs::monitoring::pacs_monitor::association_collector ( )

inlinenodiscard

Get the association collector.

Returns: Reference to the association collector

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 622 of file pacs_monitor.h.

                                                                        {
    return *association_collector_;
}

References association_collector_.

◆ check_health()

health_check_result kcenon::pacs::monitoring::pacs_monitor::check_health ( )

inlinenodiscard

Perform health check.

Returns: Health check result

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 501 of file pacs_monitor.h.

                                                      {
    const auto start = std::chrono::steady_clock::now();
    health_check_result result;
    result.status = monitor_health_status::healthy;
 
    std::lock_guard<std::mutex> lock(health_checks_mutex_);
 
    bool all_healthy = true;
    bool any_check_failed = false;
 
    for (const auto& [component, check] : health_checks_) {
        try {
            if (!check()) {
                all_healthy = false;
                result.metadata[component] = "unhealthy";
            } else {
                result.metadata[component] = "healthy";
            }
        } catch (const std::exception& e) {
            any_check_failed = true;
            result.metadata[component] = std::string("error: ") + e.what();
        }
    }
 
    // Check collectors health
    if (association_collector_ && !association_collector_->is_healthy()) {
        all_healthy = false;
        result.metadata["association_collector"] = "unhealthy";
    }
    if (service_collector_ && !service_collector_->is_healthy()) {
        all_healthy = false;
        result.metadata["service_collector"] = "unhealthy";
    }
    if (storage_collector_ && !storage_collector_->is_healthy()) {
        all_healthy = false;
        result.metadata["storage_collector"] = "unhealthy";
    }
    if (unified_collector_ && !unified_collector_->is_healthy()) {
        all_healthy = false;
        result.metadata["unified_collector"] = "unhealthy";
    }
 
    if (any_check_failed) {
        result.status = monitor_health_status::unhealthy;
        result.message = "Some health checks threw exceptions";
    } else if (!all_healthy) {
        result.status = monitor_health_status::degraded;
        result.message = "Some components are unhealthy";
    } else {
        result.message = "All components healthy";
    }
 
    const auto end = std::chrono::steady_clock::now();
    result.check_duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
 
    return result;
}

References association_collector_, kcenon::pacs::monitoring::health_check_result::check_duration, kcenon::pacs::monitoring::degraded, health_checks_, health_checks_mutex_, kcenon::pacs::monitoring::healthy, kcenon::pacs::monitoring::health_check_result::message, kcenon::pacs::monitoring::health_check_result::metadata, service_collector_, kcenon::pacs::monitoring::health_check_result::status, storage_collector_, kcenon::pacs::monitoring::unhealthy, and unified_collector_.

◆ collect_all_metrics()

void kcenon::pacs::monitoring::pacs_monitor::collect_all_metrics ( metrics_snapshot & snapshot )

inlineprivate

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 459 of file pacs_monitor.h.

                                                                        {
    std::shared_lock<std::shared_mutex> config_lock(config_mutex_);
 
    // Collect association metrics
    if (config_.enable_association_metrics && association_collector_) {
        for (const auto& m : association_collector_->collect()) {
            snapshot.add_metric(
                m.name,
                m.value,
                m.type == "counter" ? metric_type::counter : metric_type::gauge);
        }
    }
 
    // Collect service metrics
    if (config_.enable_service_metrics && service_collector_) {
        for (const auto& m : service_collector_->collect()) {
            snapshot.add_metric(
                m.name,
                m.value,
                m.type == "counter" ? metric_type::counter : metric_type::gauge);
        }
    }
 
    // Collect storage metrics
    if (config_.enable_storage_metrics && storage_collector_) {
        for (const auto& m : storage_collector_->collect()) {
            snapshot.add_metric(
                m.name,
                m.value,
                m.type == "counter" ? metric_type::counter : metric_type::gauge);
        }
    }
 
    // Add custom metrics
    {
        std::lock_guard<std::mutex> lock(custom_metrics_mutex_);
        for (const auto& m : custom_metrics_) {
            snapshot.metrics.push_back(m);
        }
    }
}

References kcenon::pacs::monitoring::metrics_snapshot::add_metric(), association_collector_, config_, config_mutex_, kcenon::pacs::monitoring::counter, custom_metrics_, custom_metrics_mutex_, kcenon::pacs::monitoring::pacs_monitor_config::enable_association_metrics, kcenon::pacs::monitoring::pacs_monitor_config::enable_service_metrics, kcenon::pacs::monitoring::pacs_monitor_config::enable_storage_metrics, kcenon::pacs::monitoring::gauge, kcenon::pacs::monitoring::metrics_snapshot::metrics, service_collector_, and storage_collector_.

Referenced by get_metrics().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ get_config()

const pacs_monitor_config & kcenon::pacs::monitoring::pacs_monitor::get_config ( ) const

inlinenodiscard

Get current configuration.

Returns: Current monitor configuration

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 592 of file pacs_monitor.h.

                                                                 {
    std::shared_lock<std::shared_mutex> lock(config_mutex_);
    return config_;
}

References config_, and config_mutex_.

◆ get_metrics()

metrics_snapshot kcenon::pacs::monitoring::pacs_monitor::get_metrics ( )

inlinenodiscard

Get current metrics snapshot.

Returns: Metrics snapshot containing all collected metrics

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 452 of file pacs_monitor.h.

                                                  {
    metrics_snapshot snapshot;
    snapshot.source_id = config_.ae_title;
    collect_all_metrics(snapshot);
    return snapshot;
}

References kcenon::pacs::monitoring::pacs_monitor_config::ae_title, collect_all_metrics(), config_, and kcenon::pacs::monitoring::metrics_snapshot::source_id.

Here is the call graph for this function:

◆ get_unified_snapshot()

dicom_metrics_snapshot kcenon::pacs::monitoring::pacs_monitor::get_unified_snapshot ( ) const

inlinenodiscard

Get a snapshot from the unified collector.

Returns: Metrics snapshot with all DICOM metrics

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 638 of file pacs_monitor.h.

                                                                       {
    if (unified_collector_) {
        return unified_collector_->get_snapshot();
    }
    return dicom_metrics_snapshot{};
}

References unified_collector_.

◆ global_monitor()

static pacs_monitor & kcenon::pacs::monitoring::pacs_monitor::global_monitor ( )

inlinestaticnodiscardnoexcept

Get the global singleton instance.

Returns: Reference to the global monitor instance

Thread-safe lazy initialization using Meyer's singleton pattern.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 246 of file pacs_monitor.h.

                                                                 {
        static pacs_monitor instance;
        return instance;
    }

◆ initialize_collectors()

void kcenon::pacs::monitoring::pacs_monitor::initialize_collectors ( )

inlineprivate

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 413 of file pacs_monitor.h.

                                                {
    association_collector_ = std::make_unique<dicom_association_collector>(config_.ae_title);
    service_collector_ = std::make_unique<dicom_service_collector>(config_.ae_title);
    storage_collector_ = std::make_unique<dicom_storage_collector>(config_.ae_title);
    unified_collector_ = std::make_unique<dicom_metrics_collector>(config_.ae_title);
 
    // Initialize all collectors
    std::unordered_map<std::string, std::string> collector_config;
    collector_config["ae_title"] = config_.ae_title;
 
    (void)association_collector_->initialize(collector_config);
    (void)service_collector_->initialize(collector_config);
    (void)storage_collector_->initialize(collector_config);
    storage_collector_->set_pool_metrics_enabled(config_.enable_pool_metrics);
 
    // Initialize unified CRTP-based collector
    config_map unified_config;
    unified_config["ae_title"] = config_.ae_title;
    unified_config["collect_associations"] = config_.enable_association_metrics ? "true" : "false";
    unified_config["collect_transfers"] = config_.enable_storage_metrics ? "true" : "false";
    unified_config["collect_storage"] = config_.enable_storage_metrics ? "true" : "false";
    unified_config["collect_queries"] = config_.enable_service_metrics ? "true" : "false";
    unified_config["collect_pools"] = config_.enable_pool_metrics ? "true" : "false";
    (void)unified_collector_->initialize(unified_config);
}

References kcenon::pacs::monitoring::pacs_monitor_config::ae_title, association_collector_, config_, kcenon::pacs::monitoring::pacs_monitor_config::enable_association_metrics, kcenon::pacs::monitoring::pacs_monitor_config::enable_pool_metrics, kcenon::pacs::monitoring::pacs_monitor_config::enable_service_metrics, kcenon::pacs::monitoring::pacs_monitor_config::enable_storage_metrics, service_collector_, storage_collector_, and unified_collector_.

Referenced by pacs_monitor().

Here is the caller graph for this function:

◆ operator=() [1/2]

pacs_monitor & kcenon::pacs::monitoring::pacs_monitor::operator= ( const pacs_monitor & )

delete

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

◆ operator=() [2/2]

pacs_monitor & kcenon::pacs::monitoring::pacs_monitor::operator= ( pacs_monitor && )

delete

◆ record_metric() [1/2]

void kcenon::pacs::monitoring::pacs_monitor::record_metric	(	std::string_view	name,
		double	value )

inline

Record a metric value.

Parameters

name	Metric name
value	Metric value

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 439 of file pacs_monitor.h.

                                                                         {
    std::lock_guard<std::mutex> lock(custom_metrics_mutex_);
    custom_metrics_.emplace_back(std::string(name), value);
}

References custom_metrics_, custom_metrics_mutex_, and name.

◆ record_metric() [2/2]

void kcenon::pacs::monitoring::pacs_monitor::record_metric	(	std::string_view	name,
		double	value,
		const std::unordered_map< std::string, std::string > &	tags )

inline

Record a metric with tags.

Parameters

name	Metric name
value	Metric value
tags	Additional metadata tags

Definition at line 444 of file pacs_monitor.h.

                                                        {
    std::lock_guard<std::mutex> lock(custom_metrics_mutex_);
    custom_metrics_.emplace_back(std::string(name), value, metric_type::gauge, tags);
}

References custom_metrics_, custom_metrics_mutex_, kcenon::pacs::monitoring::gauge, and name.

◆ register_health_check()

void kcenon::pacs::monitoring::pacs_monitor::register_health_check	(	std::string_view	component,
		std::function< bool()>	check )

inline

Register a health check for a component.

Parameters

component	Component name
check	Function that returns true if healthy

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 580 of file pacs_monitor.h.

                               {
    std::lock_guard<std::mutex> lock(health_checks_mutex_);
    health_checks_[std::string(component)] = std::move(check);
}

References health_checks_, and health_checks_mutex_.

◆ reset()

void kcenon::pacs::monitoring::pacs_monitor::reset ( )

inline

Reset all metrics.

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 559 of file pacs_monitor.h.

                                {
    // Reset underlying metrics
    pacs_metrics::global_metrics().reset();
 
    // Clear custom metrics
    {
        std::lock_guard<std::mutex> lock(custom_metrics_mutex_);
        custom_metrics_.clear();
    }
}

References custom_metrics_, custom_metrics_mutex_, kcenon::pacs::monitoring::pacs_metrics::global_metrics(), and kcenon::pacs::monitoring::pacs_metrics::reset().

Here is the call graph for this function:

◆ service_collector()

dicom_service_collector & kcenon::pacs::monitoring::pacs_monitor::service_collector ( )

inlinenodiscard

Get the service collector.

Returns: Reference to the service collector

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 626 of file pacs_monitor.h.

                                                                {
    return *service_collector_;
}

References service_collector_.

◆ storage_collector()

dicom_storage_collector & kcenon::pacs::monitoring::pacs_monitor::storage_collector ( )

inlinenodiscard

Get the storage collector.

Returns: Reference to the storage collector

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 630 of file pacs_monitor.h.

                                                                {
    return *storage_collector_;
}

References storage_collector_.

◆ to_json()

std::string kcenon::pacs::monitoring::pacs_monitor::to_json ( ) const

inlinenodiscard

Export all metrics as JSON.

Returns: JSON representation of all metrics

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 575 of file pacs_monitor.h.

                                             {
    // Use existing pacs_metrics JSON export
    return pacs_metrics::global_metrics().to_json();
}

References kcenon::pacs::monitoring::pacs_metrics::global_metrics(), and kcenon::pacs::monitoring::pacs_metrics::to_json().

Here is the call graph for this function:

◆ to_prometheus()

std::string kcenon::pacs::monitoring::pacs_monitor::to_prometheus ( ) const

inlinenodiscard

Export all metrics in Prometheus text format.

Returns: Prometheus exposition format text

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 570 of file pacs_monitor.h.

                                                   {
    // Use existing pacs_metrics Prometheus export
    return pacs_metrics::global_metrics().to_prometheus(config_.metric_prefix);
}

References config_, kcenon::pacs::monitoring::pacs_metrics::global_metrics(), kcenon::pacs::monitoring::pacs_monitor_config::metric_prefix, and kcenon::pacs::monitoring::pacs_metrics::to_prometheus().

Here is the call graph for this function:

◆ unified_collector()

dicom_metrics_collector & kcenon::pacs::monitoring::pacs_monitor::unified_collector ( )

inlinenodiscard

Get the unified CRTP-based metrics collector.

Returns: Reference to the unified metrics collector

See also: Issue #490 - CRTP-based DICOM metrics collector

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 634 of file pacs_monitor.h.

                                                                {
    return *unified_collector_;
}

References unified_collector_.

◆ unregister_health_check()

void kcenon::pacs::monitoring::pacs_monitor::unregister_health_check ( std::string_view component )

inline

Unregister a health check.

Parameters

component Component name to unregister

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 587 of file pacs_monitor.h.

                                                                          {
    std::lock_guard<std::mutex> lock(health_checks_mutex_);
    health_checks_.erase(std::string(component));
}

References health_checks_, and health_checks_mutex_.

◆ update_config()

void kcenon::pacs::monitoring::pacs_monitor::update_config ( const pacs_monitor_config & config )

inline

Update configuration.

Parameters

config New configuration

Examples: /home/runner/work/pacs_system/pacs_system/include/kcenon/pacs/monitoring/pacs_monitor.h.

Definition at line 597 of file pacs_monitor.h.

                                                                         {
    std::unique_lock<std::shared_mutex> lock(config_mutex_);
    config_ = config;
 
    // Update collector configurations
    if (association_collector_) {
        association_collector_->set_ae_title(config_.ae_title);
    }
    if (service_collector_) {
        service_collector_->set_ae_title(config_.ae_title);
    }
    if (storage_collector_) {
        storage_collector_->set_ae_title(config_.ae_title);
        storage_collector_->set_pool_metrics_enabled(config_.enable_pool_metrics);
    }
    if (unified_collector_) {
        unified_collector_->set_ae_title(config_.ae_title);
        unified_collector_->set_collect_associations(config_.enable_association_metrics);
        unified_collector_->set_collect_transfers(config_.enable_storage_metrics);
        unified_collector_->set_collect_storage(config_.enable_storage_metrics);
        unified_collector_->set_collect_queries(config_.enable_service_metrics);
        unified_collector_->set_collect_pools(config_.enable_pool_metrics);
    }
}