CRTP-based unified DICOM metrics collector. More...

#include <dicom_metrics_collector.h>

Inheritance diagram for kcenon::pacs::monitoring::dicom_metrics_collector:

Collaboration diagram for kcenon::pacs::monitoring::dicom_metrics_collector:

Public Member Functions
	dicom_metrics_collector ()=default
	Default constructor.

	dicom_metrics_collector (std::string ae_title)
	Constructor with AE title.

	~dicom_metrics_collector () override=default
	Destructor.

	dicom_metrics_collector (const dicom_metrics_collector &)=delete

dicom_metrics_collector &	operator= (const dicom_metrics_collector &)=delete

	dicom_metrics_collector (dicom_metrics_collector &&)=delete

dicom_metrics_collector &	operator= (dicom_metrics_collector &&)=delete

bool	do_initialize (const config_map &config)
	Collector-specific initialization.

std::vector< dicom_metric >	do_collect ()
	Collect all DICOM metrics.

bool	is_available () const
	Check if DICOM metrics collection is available.

std::vector< std::string >	do_get_metric_types () const
	Get supported metric types.

void	do_add_statistics (stats_map &stats) const
	Add collector-specific statistics.

dicom_metrics_snapshot	get_snapshot () const
	Get a snapshot of current metrics.

dicom_metrics_snapshot	get_last_snapshot () const
	Get last collected snapshot.

void	set_collect_associations (bool enabled)
	Enable or disable association metrics collection.

void	set_collect_transfers (bool enabled)
	Enable or disable transfer metrics collection.

void	set_collect_storage (bool enabled)
	Enable or disable storage metrics collection.

void	set_collect_queries (bool enabled)
	Enable or disable query metrics collection.

void	set_collect_pools (bool enabled)
	Enable or disable pool metrics collection.

Public Member Functions inherited from kcenon::pacs::monitoring::dicom_collector_base< dicom_metrics_collector >
	dicom_collector_base ()=default

	dicom_collector_base (const dicom_collector_base &)=delete

	dicom_collector_base (dicom_collector_base &&)=delete

virtual	~dicom_collector_base ()=default

dicom_collector_base &	operator= (const dicom_collector_base &)=delete

dicom_collector_base &	operator= (dicom_collector_base &&)=delete

bool	initialize (const config_map &config)
	Initialize the collector with configuration.

std::vector< dicom_metric >	collect ()
	Collect metrics from the data source.

std::string	get_name () const
	Get the name of this collector.

std::vector< std::string >	get_metric_types () const
	Get supported metric types.

bool	is_healthy () const
	Check if the collector is healthy.

stats_map	get_statistics () const
	Get collector statistics.

bool	is_enabled () const
	Check if collector is enabled.

std::size_t	get_collection_count () const
	Get collection count.

std::size_t	get_collection_errors () const
	Get error count.

std::string	get_ae_title () const
	Get the AE title.

void	set_ae_title (std::string ae_title)
	Set the AE title.

Static Public Attributes
static constexpr const char *	collector_name = "dicom_metrics_collector"
	Collector name for CRTP base class.

Private Member Functions
void	collect_association_metrics (std::vector< dicom_metric > &metrics)

void	collect_transfer_metrics (std::vector< dicom_metric > &metrics)

void	collect_storage_metrics (std::vector< dicom_metric > &metrics)

void	collect_query_metrics (std::vector< dicom_metric > &metrics)

void	collect_pool_metrics (std::vector< dicom_metric > &metrics)

void	collect_dimse_operation_metrics (std::vector< dicom_metric > &metrics, const std::string &op_name, const operation_counter &counter)

Private Attributes
bool	collect_associations_ {true}

bool	collect_transfers_ {true}

bool	collect_storage_ {true}

bool	collect_queries_ {true}

bool	collect_pools_ {true}

std::mutex	snapshot_mutex_

dicom_metrics_snapshot	last_snapshot_

Additional Inherited Members
Protected Member Functions inherited from kcenon::pacs::monitoring::dicom_collector_base< dicom_metrics_collector >
dicom_metric	create_base_metric (const std::string &name, double value, const std::string &type, const std::unordered_map< std::string, std::string > &extra_tags={}) const
	Create a metric with common tags.

Protected Attributes inherited from kcenon::pacs::monitoring::dicom_collector_base< dicom_metrics_collector >
bool	enabled_

std::string	ae_title_

std::mutex	stats_mutex_

std::atomic< std::size_t >	collection_count_

std::atomic< std::size_t >	collection_errors_

std::chrono::steady_clock::time_point	init_time_

std::chrono::system_clock::time_point	last_collection_time_

Detailed Description

CRTP-based unified DICOM metrics collector.

This collector gathers all DICOM-related metrics in a single, efficient collection pass, following the monitoring_system's CRTP collector pattern.

Collected metrics include:

Association metrics (opened, closed, duration)
Transfer metrics (images, bytes, rate)
Storage metrics (operations, latency)
Query metrics (C-FIND, C-MOVE)
Pool metrics (element, dataset, PDU buffer)

Performance targets (based on monitoring_system benchmarks):

Metric collection: < 100ns per operation
Memory overhead: < 1MB for counters
CPU overhead: < 1% at 1000 ops/sec

Thread Safety: All public methods are thread-safe.

Definition at line 108 of file dicom_metrics_collector.h.

Constructor & Destructor Documentation

◆ dicom_metrics_collector() [1/4]

kcenon::pacs::monitoring::dicom_metrics_collector::dicom_metrics_collector ( )

default

Default constructor.

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

◆ dicom_metrics_collector() [2/4]

kcenon::pacs::monitoring::dicom_metrics_collector::dicom_metrics_collector ( std::string ae_title )

inlineexplicit

Constructor with AE title.

Parameters

ae_title Application Entity title for metric labels

Definition at line 258 of file dicom_metrics_collector.h.

                                                                          {
    ae_title_ = std::move(ae_title);
}

References kcenon::pacs::monitoring::dicom_collector_base< dicom_metrics_collector >::ae_title_.

◆ ~dicom_metrics_collector()

kcenon::pacs::monitoring::dicom_metrics_collector::~dicom_metrics_collector ( )

overridedefault

Destructor.

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

◆ dicom_metrics_collector() [3/4]

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

delete

◆ dicom_metrics_collector() [4/4]

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

delete

Member Function Documentation

◆ collect_association_metrics()

void kcenon::pacs::monitoring::dicom_metrics_collector::collect_association_metrics ( std::vector< dicom_metric > & metrics )

inlineprivate

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

Definition at line 435 of file dicom_metrics_collector.h.

                                      {
 
    const auto& assoc = pacs_metrics::global_metrics().associations();
 
    // Active associations (gauge)
    metrics.push_back(create_base_metric(
        "dicom_associations_active",
        static_cast<double>(assoc.current_active.load(std::memory_order_relaxed)),
        "gauge"));
 
    // Peak active associations (gauge)
    metrics.push_back(create_base_metric(
        "dicom_associations_peak",
        static_cast<double>(assoc.peak_active.load(std::memory_order_relaxed)),
        "gauge"));
 
    // Total established (counter)
    metrics.push_back(create_base_metric(
        "dicom_associations_total",
        static_cast<double>(assoc.total_established.load(std::memory_order_relaxed)),
        "counter"));
 
    // Rejected (counter)
    metrics.push_back(create_base_metric(
        "dicom_associations_rejected_total",
        static_cast<double>(assoc.total_rejected.load(std::memory_order_relaxed)),
        "counter"));
 
    // Aborted (counter)
    metrics.push_back(create_base_metric(
        "dicom_associations_aborted_total",
        static_cast<double>(assoc.total_aborted.load(std::memory_order_relaxed)),
        "counter"));
 
    // Success rate (gauge)
    const auto total = assoc.total_established.load(std::memory_order_relaxed);
    const auto rejected = assoc.total_rejected.load(std::memory_order_relaxed);
    const auto attempted = total + rejected;
    const double success_rate = (attempted > 0)
        ? static_cast<double>(total) / static_cast<double>(attempted)
        : 1.0;
 
    metrics.push_back(create_base_metric(
        "dicom_associations_success_rate",
        success_rate,
        "gauge"));
}

References kcenon::pacs::monitoring::pacs_metrics::associations(), kcenon::pacs::monitoring::dicom_collector_base< dicom_metrics_collector >::create_base_metric(), and kcenon::pacs::monitoring::pacs_metrics::global_metrics().

Referenced by do_collect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_dimse_operation_metrics()

void kcenon::pacs::monitoring::dicom_metrics_collector::collect_dimse_operation_metrics	(	std::vector< dicom_metric > &	metrics,
		const std::string &	op_name,
		const operation_counter &	counter )

inlineprivate

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

Definition at line 629 of file dicom_metrics_collector.h.

                                      {
 
    std::unordered_map<std::string, std::string> op_tags{{"operation", op_name}};
 
    // Total requests (counter)
    metrics.push_back(create_base_metric(
        "dicom_" + op_name + "_total",
        static_cast<double>(counter.total_count()),
        "counter",
        op_tags));
 
    // Successful requests (counter)
    metrics.push_back(create_base_metric(
        "dicom_" + op_name + "_success_total",
        static_cast<double>(counter.success_count.load(std::memory_order_relaxed)),
        "counter",
        op_tags));
 
    // Failed requests (counter)
    metrics.push_back(create_base_metric(
        "dicom_" + op_name + "_failure_total",
        static_cast<double>(counter.failure_count.load(std::memory_order_relaxed)),
        "counter",
        op_tags));
 
    // Duration metrics (only if there have been requests)
    if (counter.total_count() > 0) {
        // Average duration in seconds (gauge)
        metrics.push_back(create_base_metric(
            "dicom_" + op_name + "_duration_seconds_avg",
            static_cast<double>(counter.average_duration_us()) / 1'000'000.0,
            "gauge",
            op_tags));
 
        // Total duration in seconds (counter) - for rate calculations
        metrics.push_back(create_base_metric(
            "dicom_" + op_name + "_duration_seconds_sum",
            static_cast<double>(counter.total_duration_us.load(std::memory_order_relaxed)) / 1'000'000.0,
            "counter",
            op_tags));
 
        // Min duration (gauge)
        const auto min_us = counter.min_duration_us.load(std::memory_order_relaxed);
        if (min_us != UINT64_MAX) {
            metrics.push_back(create_base_metric(
                "dicom_" + op_name + "_duration_seconds_min",
                static_cast<double>(min_us) / 1'000'000.0,
                "gauge",
                op_tags));
        }
 
        // Max duration (gauge)
        const auto max_us = counter.max_duration_us.load(std::memory_order_relaxed);
        if (max_us > 0) {
            metrics.push_back(create_base_metric(
                "dicom_" + op_name + "_duration_seconds_max",
                static_cast<double>(max_us) / 1'000'000.0,
                "gauge",
                op_tags));
        }
    }
}

References kcenon::pacs::monitoring::counter.

Referenced by collect_query_metrics(), and collect_storage_metrics().

Here is the caller graph for this function:

◆ collect_pool_metrics()

void kcenon::pacs::monitoring::dicom_metrics_collector::collect_pool_metrics ( std::vector< dicom_metric > & metrics )

inlineprivate

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

Definition at line 554 of file dicom_metrics_collector.h.

                                      {
 
    const auto& pacs = pacs_metrics::global_metrics();
 
    // Element pool
    const auto& elem_pool = pacs.element_pool();
    metrics.push_back(create_base_metric(
        "dicom_element_pool_acquisitions_total",
        static_cast<double>(elem_pool.total_acquisitions.load(std::memory_order_relaxed)),
        "counter",
        {{"pool", "element"}}));
    metrics.push_back(create_base_metric(
        "dicom_element_pool_hits_total",
        static_cast<double>(elem_pool.pool_hits.load(std::memory_order_relaxed)),
        "counter",
        {{"pool", "element"}}));
    metrics.push_back(create_base_metric(
        "dicom_element_pool_misses_total",
        static_cast<double>(elem_pool.pool_misses.load(std::memory_order_relaxed)),
        "counter",
        {{"pool", "element"}}));
    metrics.push_back(create_base_metric(
        "dicom_element_pool_hit_ratio",
        elem_pool.hit_ratio(),
        "gauge",
        {{"pool", "element"}}));
 
    // Dataset pool
    const auto& ds_pool = pacs.dataset_pool();
    metrics.push_back(create_base_metric(
        "dicom_dataset_pool_acquisitions_total",
        static_cast<double>(ds_pool.total_acquisitions.load(std::memory_order_relaxed)),
        "counter",
        {{"pool", "dataset"}}));
    metrics.push_back(create_base_metric(
        "dicom_dataset_pool_hits_total",
        static_cast<double>(ds_pool.pool_hits.load(std::memory_order_relaxed)),
        "counter",
        {{"pool", "dataset"}}));
    metrics.push_back(create_base_metric(
        "dicom_dataset_pool_misses_total",
        static_cast<double>(ds_pool.pool_misses.load(std::memory_order_relaxed)),
        "counter",
        {{"pool", "dataset"}}));
    metrics.push_back(create_base_metric(
        "dicom_dataset_pool_hit_ratio",
        ds_pool.hit_ratio(),
        "gauge",
        {{"pool", "dataset"}}));
 
    // PDU buffer pool
    const auto& pdu_pool = pacs.pdu_buffer_pool();
    metrics.push_back(create_base_metric(
        "dicom_pdu_buffer_pool_acquisitions_total",
        static_cast<double>(pdu_pool.total_acquisitions.load(std::memory_order_relaxed)),
        "counter",
        {{"pool", "pdu_buffer"}}));
    metrics.push_back(create_base_metric(
        "dicom_pdu_buffer_pool_hits_total",
        static_cast<double>(pdu_pool.pool_hits.load(std::memory_order_relaxed)),
        "counter",
        {{"pool", "pdu_buffer"}}));
    metrics.push_back(create_base_metric(
        "dicom_pdu_buffer_pool_misses_total",
        static_cast<double>(pdu_pool.pool_misses.load(std::memory_order_relaxed)),
        "counter",
        {{"pool", "pdu_buffer"}}));
    metrics.push_back(create_base_metric(
        "dicom_pdu_buffer_pool_hit_ratio",
        pdu_pool.hit_ratio(),
        "gauge",
        {{"pool", "pdu_buffer"}}));
}

References kcenon::pacs::monitoring::dicom_collector_base< dicom_metrics_collector >::create_base_metric(), and kcenon::pacs::monitoring::pacs_metrics::global_metrics().

Referenced by do_collect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_query_metrics()

void kcenon::pacs::monitoring::dicom_metrics_collector::collect_query_metrics ( std::vector< dicom_metric > & metrics )

inlineprivate

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

Definition at line 524 of file dicom_metrics_collector.h.

                                      {
 
    const auto& pacs = pacs_metrics::global_metrics();
 
    // All query-related DIMSE operations
    collect_dimse_operation_metrics(
        metrics, "c_echo", pacs.get_counter(dimse_operation::c_echo));
    collect_dimse_operation_metrics(
        metrics, "c_find", pacs.get_counter(dimse_operation::c_find));
    collect_dimse_operation_metrics(
        metrics, "c_move", pacs.get_counter(dimse_operation::c_move));
    collect_dimse_operation_metrics(
        metrics, "c_get", pacs.get_counter(dimse_operation::c_get));
 
    // N-services
    collect_dimse_operation_metrics(
        metrics, "n_create", pacs.get_counter(dimse_operation::n_create));
    collect_dimse_operation_metrics(
        metrics, "n_set", pacs.get_counter(dimse_operation::n_set));
    collect_dimse_operation_metrics(
        metrics, "n_get", pacs.get_counter(dimse_operation::n_get));
    collect_dimse_operation_metrics(
        metrics, "n_action", pacs.get_counter(dimse_operation::n_action));
    collect_dimse_operation_metrics(
        metrics, "n_event", pacs.get_counter(dimse_operation::n_event));
    collect_dimse_operation_metrics(
        metrics, "n_delete", pacs.get_counter(dimse_operation::n_delete));
}

References kcenon::pacs::monitoring::c_echo, kcenon::pacs::monitoring::c_find, kcenon::pacs::monitoring::c_get, kcenon::pacs::monitoring::c_move, collect_dimse_operation_metrics(), kcenon::pacs::monitoring::pacs_metrics::global_metrics(), kcenon::pacs::monitoring::n_action, kcenon::pacs::monitoring::n_create, kcenon::pacs::monitoring::n_delete, kcenon::pacs::monitoring::n_event, kcenon::pacs::monitoring::n_get, and kcenon::pacs::monitoring::n_set.

Referenced by do_collect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_storage_metrics()

void kcenon::pacs::monitoring::dicom_metrics_collector::collect_storage_metrics ( std::vector< dicom_metric > & metrics )

inlineprivate

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

Definition at line 514 of file dicom_metrics_collector.h.

                                      {
 
    const auto& pacs = pacs_metrics::global_metrics();
 
    // C-STORE operation metrics
    collect_dimse_operation_metrics(
        metrics, "c_store", pacs.get_counter(dimse_operation::c_store));
}

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

Referenced by do_collect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ collect_transfer_metrics()

void kcenon::pacs::monitoring::dicom_metrics_collector::collect_transfer_metrics ( std::vector< dicom_metric > & metrics )

inlineprivate

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

Definition at line 484 of file dicom_metrics_collector.h.

                                      {
 
    const auto& transfer = pacs_metrics::global_metrics().transfer();
 
    // Images stored (counter)
    metrics.push_back(create_base_metric(
        "dicom_images_stored_total",
        static_cast<double>(transfer.images_stored.load(std::memory_order_relaxed)),
        "counter"));
 
    // Images retrieved (counter)
    metrics.push_back(create_base_metric(
        "dicom_images_retrieved_total",
        static_cast<double>(transfer.images_retrieved.load(std::memory_order_relaxed)),
        "counter"));
 
    // Bytes sent (counter)
    metrics.push_back(create_base_metric(
        "dicom_bytes_sent_total",
        static_cast<double>(transfer.bytes_sent.load(std::memory_order_relaxed)),
        "counter"));
 
    // Bytes received (counter)
    metrics.push_back(create_base_metric(
        "dicom_bytes_received_total",
        static_cast<double>(transfer.bytes_received.load(std::memory_order_relaxed)),
        "counter"));
}

References kcenon::pacs::monitoring::dicom_collector_base< dicom_metrics_collector >::create_base_metric(), kcenon::pacs::monitoring::pacs_metrics::global_metrics(), and kcenon::pacs::monitoring::pacs_metrics::transfer().

Referenced by do_collect().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ do_add_statistics()

void kcenon::pacs::monitoring::dicom_metrics_collector::do_add_statistics ( stats_map & stats ) const

inline

Add collector-specific statistics.

Parameters

stats Map to add statistics to

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

Definition at line 348 of file dicom_metrics_collector.h.

                                                                             {
    std::lock_guard<std::mutex> lock(snapshot_mutex_);
 
    stats["active_associations"] =
        static_cast<double>(last_snapshot_.active_associations);
    stats["total_images_processed"] =
        static_cast<double>(last_snapshot_.images_sent + last_snapshot_.images_received);
    stats["total_bytes_transferred"] =
        static_cast<double>(last_snapshot_.bytes_sent + last_snapshot_.bytes_received);
}

References kcenon::pacs::monitoring::dicom_metrics_snapshot::active_associations, kcenon::pacs::monitoring::dicom_metrics_snapshot::bytes_received, kcenon::pacs::monitoring::dicom_metrics_snapshot::bytes_sent, kcenon::pacs::monitoring::dicom_metrics_snapshot::images_received, kcenon::pacs::monitoring::dicom_metrics_snapshot::images_sent, last_snapshot_, and snapshot_mutex_.

◆ do_collect()

std::vector< dicom_metric > kcenon::pacs::monitoring::dicom_metrics_collector::do_collect ( )

inline

Collect all DICOM metrics.

Returns: Vector of collected metrics

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

Definition at line 283 of file dicom_metrics_collector.h.

                                                                   {
    std::vector<dicom_metric> metrics;
    metrics.reserve(64);  // Pre-allocate for typical metric count
 
    if (collect_associations_) {
        collect_association_metrics(metrics);
    }
    if (collect_transfers_) {
        collect_transfer_metrics(metrics);
    }
    if (collect_storage_) {
        collect_storage_metrics(metrics);
    }
    if (collect_queries_) {
        collect_query_metrics(metrics);
    }
    if (collect_pools_) {
        collect_pool_metrics(metrics);
    }
 
    return metrics;
}

References collect_association_metrics(), collect_associations_, collect_pool_metrics(), collect_pools_, collect_queries_, collect_query_metrics(), collect_storage_, collect_storage_metrics(), collect_transfer_metrics(), and collect_transfers_.

Here is the call graph for this function:

◆ do_get_metric_types()

std::vector< std::string > kcenon::pacs::monitoring::dicom_metrics_collector::do_get_metric_types ( ) const

inlinenodiscard

Get supported metric types.

Returns: Vector of supported metric type names

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

Definition at line 310 of file dicom_metrics_collector.h.

                                                                               {
    std::vector<std::string> types;
 
    // Association metrics
    types.push_back("dicom_associations_active");
    types.push_back("dicom_associations_peak");
    types.push_back("dicom_associations_total");
    types.push_back("dicom_associations_rejected_total");
    types.push_back("dicom_associations_aborted_total");
 
    // Transfer metrics
    types.push_back("dicom_images_sent_total");
    types.push_back("dicom_images_received_total");
    types.push_back("dicom_bytes_sent_total");
    types.push_back("dicom_bytes_received_total");
    types.push_back("dicom_transfer_rate_mbps");
 
    // DIMSE operation metrics
    static constexpr std::array<const char*, 11> ops = {
        "c_echo", "c_store", "c_find", "c_move", "c_get",
        "n_create", "n_set", "n_get", "n_action", "n_event", "n_delete"
    };
    for (const auto* op : ops) {
        types.push_back(std::string("dicom_") + op + "_total");
        types.push_back(std::string("dicom_") + op + "_success_total");
        types.push_back(std::string("dicom_") + op + "_failure_total");
        types.push_back(std::string("dicom_") + op + "_duration_seconds");
    }
 
    // Pool metrics
    types.push_back("dicom_element_pool_hits");
    types.push_back("dicom_element_pool_misses");
    types.push_back("dicom_dataset_pool_hits");
    types.push_back("dicom_dataset_pool_misses");
 
    return types;
}

◆ do_initialize()

bool kcenon::pacs::monitoring::dicom_metrics_collector::do_initialize ( const config_map & config )

inline

Collector-specific initialization.

Parameters

config

Configuration options:

"collect_associations": "true"/"false" (default: true)
"collect_transfers": "true"/"false" (default: true)
"collect_storage": "true"/"false" (default: true)
"collect_queries": "true"/"false" (default: true)
"collect_pools": "true"/"false" (default: true)

Returns: true if initialization successful

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

Definition at line 262 of file dicom_metrics_collector.h.

                                                                           {
    // Parse collection configuration
    if (auto it = config.find("collect_associations"); it != config.end()) {
        collect_associations_ = (it->second == "true" || it->second == "1");
    }
    if (auto it = config.find("collect_transfers"); it != config.end()) {
        collect_transfers_ = (it->second == "true" || it->second == "1");
    }
    if (auto it = config.find("collect_storage"); it != config.end()) {
        collect_storage_ = (it->second == "true" || it->second == "1");
    }
    if (auto it = config.find("collect_queries"); it != config.end()) {
        collect_queries_ = (it->second == "true" || it->second == "1");
    }
    if (auto it = config.find("collect_pools"); it != config.end()) {
        collect_pools_ = (it->second == "true" || it->second == "1");
    }
 
    return true;
}

References collect_associations_, collect_pools_, collect_queries_, collect_storage_, and collect_transfers_.

◆ get_last_snapshot()

dicom_metrics_snapshot kcenon::pacs::monitoring::dicom_metrics_collector::get_last_snapshot ( ) const

inlinenodiscard

Get last collected snapshot.

Returns: Last metrics snapshot (thread-safe copy)

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

Definition at line 410 of file dicom_metrics_collector.h.

                                                                               {
    std::lock_guard<std::mutex> lock(snapshot_mutex_);
    return last_snapshot_;
}

References last_snapshot_, and snapshot_mutex_.

◆ get_snapshot()

dicom_metrics_snapshot kcenon::pacs::monitoring::dicom_metrics_collector::get_snapshot ( ) const

inlinenodiscard

Get a snapshot of current metrics.

Returns: Metrics snapshot

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

Definition at line 359 of file dicom_metrics_collector.h.

                                                                          {
    dicom_metrics_snapshot snapshot;
    snapshot.timestamp = std::chrono::system_clock::now();
 
    const auto& pacs = pacs_metrics::global_metrics();
    const auto& assoc = pacs.associations();
    const auto& transfer = pacs.transfer();
 
    // Association metrics
    snapshot.total_associations =
        assoc.total_established.load(std::memory_order_relaxed);
    snapshot.active_associations =
        assoc.current_active.load(std::memory_order_relaxed);
    snapshot.failed_associations =
        assoc.total_rejected.load(std::memory_order_relaxed) +
        assoc.total_aborted.load(std::memory_order_relaxed);
    snapshot.peak_active_associations =
        assoc.peak_active.load(std::memory_order_relaxed);
 
    // Transfer metrics
    snapshot.images_sent = 0;  // Not tracked separately
    snapshot.images_received =
        transfer.images_stored.load(std::memory_order_relaxed);
    snapshot.bytes_sent =
        transfer.bytes_sent.load(std::memory_order_relaxed);
    snapshot.bytes_received =
        transfer.bytes_received.load(std::memory_order_relaxed);
 
    // Storage metrics (from C-STORE counter)
    const auto& store = pacs.get_counter(dimse_operation::c_store);
    snapshot.store_operations = store.total_count();
    snapshot.successful_stores =
        store.success_count.load(std::memory_order_relaxed);
    snapshot.failed_stores =
        store.failure_count.load(std::memory_order_relaxed);
    snapshot.avg_store_latency_ms =
        static_cast<double>(store.average_duration_us()) / 1000.0;
 
    // Query metrics (from C-FIND counter)
    const auto& query = pacs.get_counter(dimse_operation::c_find);
    snapshot.query_operations = query.total_count();
    snapshot.successful_queries =
        query.success_count.load(std::memory_order_relaxed);
    snapshot.failed_queries =
        query.failure_count.load(std::memory_order_relaxed);
    snapshot.avg_query_latency_ms =
        static_cast<double>(query.average_duration_us()) / 1000.0;
 
    return snapshot;
}

Here is the call graph for this function:

◆ is_available()

bool kcenon::pacs::monitoring::dicom_metrics_collector::is_available ( ) const

inlinenodiscard

Check if DICOM metrics collection is available.

Returns: true (always available as pacs_metrics is always present)

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

Definition at line 306 of file dicom_metrics_collector.h.

                                                        {
    return true;  // pacs_metrics singleton is always available
}

◆ operator=() [1/2]

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

delete

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

◆ operator=() [2/2]

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

delete

◆ set_collect_associations()

void kcenon::pacs::monitoring::dicom_metrics_collector::set_collect_associations ( bool enabled )

inline

Enable or disable association metrics collection.

Parameters

enabled Whether to collect association metrics

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

Definition at line 415 of file dicom_metrics_collector.h.

                                                                          {
    collect_associations_ = enabled;
}

References collect_associations_.

◆ set_collect_pools()

void kcenon::pacs::monitoring::dicom_metrics_collector::set_collect_pools ( bool enabled )

inline

Enable or disable pool metrics collection.

Parameters

enabled Whether to collect pool metrics

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

Definition at line 431 of file dicom_metrics_collector.h.

                                                                   {
    collect_pools_ = enabled;
}

References collect_pools_.

◆ set_collect_queries()

void kcenon::pacs::monitoring::dicom_metrics_collector::set_collect_queries ( bool enabled )

inline

Enable or disable query metrics collection.

Parameters

enabled Whether to collect query metrics

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

Definition at line 427 of file dicom_metrics_collector.h.

                                                                     {
    collect_queries_ = enabled;
}

References collect_queries_.

◆ set_collect_storage()

void kcenon::pacs::monitoring::dicom_metrics_collector::set_collect_storage ( bool enabled )

inline

Enable or disable storage metrics collection.

Parameters

enabled Whether to collect storage metrics

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

Definition at line 423 of file dicom_metrics_collector.h.

                                                                     {
    collect_storage_ = enabled;
}

References collect_storage_.

◆ set_collect_transfers()

void kcenon::pacs::monitoring::dicom_metrics_collector::set_collect_transfers ( bool enabled )

inline

Enable or disable transfer metrics collection.

Parameters

enabled Whether to collect transfer metrics

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

Definition at line 419 of file dicom_metrics_collector.h.

                                                                       {
    collect_transfers_ = enabled;
}

References collect_transfers_.

Member Data Documentation

◆ collect_associations_

bool kcenon::pacs::monitoring::dicom_metrics_collector::collect_associations_ {true}

private

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

Definition at line 232 of file dicom_metrics_collector.h.

232{true};

Referenced by do_collect(), do_initialize(), and set_collect_associations().

◆ collect_pools_

bool kcenon::pacs::monitoring::dicom_metrics_collector::collect_pools_ {true}

private

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

Definition at line 236 of file dicom_metrics_collector.h.

236{true};

Referenced by do_collect(), do_initialize(), and set_collect_pools().

◆ collect_queries_

bool kcenon::pacs::monitoring::dicom_metrics_collector::collect_queries_ {true}

private

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

Definition at line 235 of file dicom_metrics_collector.h.

235{true};

Referenced by do_collect(), do_initialize(), and set_collect_queries().

◆ collect_storage_

bool kcenon::pacs::monitoring::dicom_metrics_collector::collect_storage_ {true}

private

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

Definition at line 234 of file dicom_metrics_collector.h.

234{true};

Referenced by do_collect(), do_initialize(), and set_collect_storage().

◆ collect_transfers_

bool kcenon::pacs::monitoring::dicom_metrics_collector::collect_transfers_ {true}

private

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

Definition at line 233 of file dicom_metrics_collector.h.

233{true};

Referenced by do_collect(), do_initialize(), and set_collect_transfers().

◆ collector_name

const char* kcenon::pacs::monitoring::dicom_metrics_collector::collector_name = "dicom_metrics_collector"

staticconstexpr

Collector name for CRTP base class.

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

Definition at line 112 of file dicom_metrics_collector.h.

◆ last_snapshot_

dicom_metrics_snapshot kcenon::pacs::monitoring::dicom_metrics_collector::last_snapshot_

private

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

Definition at line 240 of file dicom_metrics_collector.h.

Referenced by do_add_statistics(), and get_last_snapshot().

◆ snapshot_mutex_

std::mutex kcenon::pacs::monitoring::dicom_metrics_collector::snapshot_mutex_

mutableprivate

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

Definition at line 239 of file dicom_metrics_collector.h.

Referenced by do_add_statistics(), and get_last_snapshot().

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

include/kcenon/pacs/monitoring/collectors/dicom_metrics_collector.h

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ dicom_metrics_collector() [1/4]

◆ dicom_metrics_collector() [2/4]

◆ ~dicom_metrics_collector()

◆ dicom_metrics_collector() [3/4]

◆ dicom_metrics_collector() [4/4]

Member Function Documentation

◆ collect_association_metrics()

◆ collect_dimse_operation_metrics()

◆ collect_pool_metrics()

◆ collect_query_metrics()

◆ collect_storage_metrics()

◆ collect_transfer_metrics()

◆ do_add_statistics()

◆ do_collect()

◆ do_get_metric_types()

◆ do_initialize()

◆ get_last_snapshot()

◆ get_snapshot()

◆ is_available()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ set_collect_associations()

◆ set_collect_pools()

◆ set_collect_queries()

◆ set_collect_storage()

◆ set_collect_transfers()

Member Data Documentation

◆ collect_associations_

◆ collect_pools_

◆ collect_queries_

◆ collect_storage_

◆ collect_transfers_

◆ collector_name

◆ last_snapshot_

◆ snapshot_mutex_