pacs_metrics.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <sstream>
#include <string>
#include <string_view>
 
namespace kcenon::pacs::monitoring {
 
enum class dimse_operation {
    c_echo,   
    c_store,  
    c_find,   
    c_move,   
    c_get,    
    n_create, 
    n_set,    
    n_get,    
    n_action, 
    n_event,  
    n_delete  
};
 
[[nodiscard]] constexpr std::string_view to_string(dimse_operation op) noexcept {
    switch (op) {
        case dimse_operation::c_echo:
            return "c_echo";
        case dimse_operation::c_store:
            return "c_store";
        case dimse_operation::c_find:
            return "c_find";
        case dimse_operation::c_move:
            return "c_move";
        case dimse_operation::c_get:
            return "c_get";
        case dimse_operation::n_create:
            return "n_create";
        case dimse_operation::n_set:
            return "n_set";
        case dimse_operation::n_get:
            return "n_get";
        case dimse_operation::n_action:
            return "n_action";
        case dimse_operation::n_event:
            return "n_event";
        case dimse_operation::n_delete:
            return "n_delete";
        default:
            return "unknown";
    }
}
 
struct operation_counter {
    std::atomic<std::uint64_t> success_count{0};
    std::atomic<std::uint64_t> failure_count{0};
    std::atomic<std::uint64_t> total_duration_us{0};  
    std::atomic<std::uint64_t> min_duration_us{UINT64_MAX};
    std::atomic<std::uint64_t> max_duration_us{0};
 
    [[nodiscard]] std::uint64_t total_count() const noexcept {
        return success_count.load(std::memory_order_relaxed) +
               failure_count.load(std::memory_order_relaxed);
    }
 
    [[nodiscard]] std::uint64_t average_duration_us() const noexcept {
        const auto total = total_count();
        if (total == 0) {
            return 0;
        }
        return total_duration_us.load(std::memory_order_relaxed) / total;
    }
 
    void record_success(std::chrono::microseconds duration) noexcept {
        success_count.fetch_add(1, std::memory_order_relaxed);
        const auto duration_us = static_cast<std::uint64_t>(duration.count());
        total_duration_us.fetch_add(duration_us, std::memory_order_relaxed);
 
        // Update min/max with CAS loops
        auto current_min = min_duration_us.load(std::memory_order_relaxed);
        while (duration_us < current_min &&
               !min_duration_us.compare_exchange_weak(current_min, duration_us,
                                                       std::memory_order_relaxed)) {
            // Loop until successful
        }
 
        auto current_max = max_duration_us.load(std::memory_order_relaxed);
        while (duration_us > current_max &&
               !max_duration_us.compare_exchange_weak(current_max, duration_us,
                                                       std::memory_order_relaxed)) {
            // Loop until successful
        }
    }
 
    void record_failure(std::chrono::microseconds duration) noexcept {
        failure_count.fetch_add(1, std::memory_order_relaxed);
        const auto duration_us = static_cast<std::uint64_t>(duration.count());
        total_duration_us.fetch_add(duration_us, std::memory_order_relaxed);
 
        // Update min/max with CAS loops
        auto current_min = min_duration_us.load(std::memory_order_relaxed);
        while (duration_us < current_min &&
               !min_duration_us.compare_exchange_weak(current_min, duration_us,
                                                       std::memory_order_relaxed)) {
        }
 
        auto current_max = max_duration_us.load(std::memory_order_relaxed);
        while (duration_us > current_max &&
               !max_duration_us.compare_exchange_weak(current_max, duration_us,
                                                       std::memory_order_relaxed)) {
        }
    }
 
    void reset() noexcept {
        success_count.store(0, std::memory_order_relaxed);
        failure_count.store(0, std::memory_order_relaxed);
        total_duration_us.store(0, std::memory_order_relaxed);
        min_duration_us.store(UINT64_MAX, std::memory_order_relaxed);
        max_duration_us.store(0, std::memory_order_relaxed);
    }
};
 
struct data_transfer_metrics {
    std::atomic<std::uint64_t> bytes_sent{0};
    std::atomic<std::uint64_t> bytes_received{0};
    std::atomic<std::uint64_t> images_stored{0};
    std::atomic<std::uint64_t> images_retrieved{0};
 
    void add_bytes_sent(std::uint64_t bytes) noexcept {
        bytes_sent.fetch_add(bytes, std::memory_order_relaxed);
    }
 
    void add_bytes_received(std::uint64_t bytes) noexcept {
        bytes_received.fetch_add(bytes, std::memory_order_relaxed);
    }
 
    void increment_images_stored() noexcept {
        images_stored.fetch_add(1, std::memory_order_relaxed);
    }
 
    void increment_images_retrieved() noexcept {
        images_retrieved.fetch_add(1, std::memory_order_relaxed);
    }
 
    void reset() noexcept {
        bytes_sent.store(0, std::memory_order_relaxed);
        bytes_received.store(0, std::memory_order_relaxed);
        images_stored.store(0, std::memory_order_relaxed);
        images_retrieved.store(0, std::memory_order_relaxed);
    }
};
 
struct association_counters {
    std::atomic<std::uint64_t> total_established{0};
    std::atomic<std::uint64_t> total_rejected{0};
    std::atomic<std::uint64_t> total_aborted{0};
    std::atomic<std::uint32_t> current_active{0};
    std::atomic<std::uint32_t> peak_active{0};
 
    void record_established() noexcept {
        total_established.fetch_add(1, std::memory_order_relaxed);
        const auto active = current_active.fetch_add(1, std::memory_order_relaxed) + 1;
 
        // Update peak with CAS loop
        auto current_peak = peak_active.load(std::memory_order_relaxed);
        while (active > current_peak &&
               !peak_active.compare_exchange_weak(current_peak, active,
                                                   std::memory_order_relaxed)) {
        }
    }
 
    void record_released() noexcept {
        const auto prev = current_active.load(std::memory_order_relaxed);
        if (prev > 0) {
            current_active.fetch_sub(1, std::memory_order_relaxed);
        }
    }
 
    void record_rejected() noexcept {
        total_rejected.fetch_add(1, std::memory_order_relaxed);
    }
 
    void record_aborted() noexcept {
        total_aborted.fetch_add(1, std::memory_order_relaxed);
        const auto prev = current_active.load(std::memory_order_relaxed);
        if (prev > 0) {
            current_active.fetch_sub(1, std::memory_order_relaxed);
        }
    }
 
    void reset() noexcept {
        total_established.store(0, std::memory_order_relaxed);
        total_rejected.store(0, std::memory_order_relaxed);
        total_aborted.store(0, std::memory_order_relaxed);
        current_active.store(0, std::memory_order_relaxed);
        peak_active.store(0, std::memory_order_relaxed);
    }
};
 
struct pool_counters {
    std::atomic<std::uint64_t> total_acquisitions{0};
    std::atomic<std::uint64_t> pool_hits{0};
    std::atomic<std::uint64_t> pool_misses{0};
    std::atomic<std::uint64_t> total_releases{0};
    std::atomic<std::uint32_t> current_pool_size{0};
 
    [[nodiscard]] double hit_ratio() const noexcept {
        const auto total = total_acquisitions.load(std::memory_order_relaxed);
        if (total == 0) {
            return 0.0;
        }
        return static_cast<double>(pool_hits.load(std::memory_order_relaxed))
               / static_cast<double>(total);
    }
 
    void record_acquisition(bool was_pool_hit) noexcept {
        total_acquisitions.fetch_add(1, std::memory_order_relaxed);
        if (was_pool_hit) {
            pool_hits.fetch_add(1, std::memory_order_relaxed);
        } else {
            pool_misses.fetch_add(1, std::memory_order_relaxed);
        }
    }
 
    void record_release() noexcept {
        total_releases.fetch_add(1, std::memory_order_relaxed);
    }
 
    void set_pool_size(std::uint32_t size) noexcept {
        current_pool_size.store(size, std::memory_order_relaxed);
    }
 
    void reset() noexcept {
        total_acquisitions.store(0, std::memory_order_relaxed);
        pool_hits.store(0, std::memory_order_relaxed);
        pool_misses.store(0, std::memory_order_relaxed);
        total_releases.store(0, std::memory_order_relaxed);
        current_pool_size.store(0, std::memory_order_relaxed);
    }
};
 
class pacs_metrics {
public:
    // =========================================================================
    // Construction and Global Access
    // =========================================================================
 
    pacs_metrics() = default;
 
    [[nodiscard]] static pacs_metrics& global_metrics() noexcept {
        static pacs_metrics instance;
        return instance;
    }
 
    pacs_metrics(const pacs_metrics&) = delete;
    pacs_metrics& operator=(const pacs_metrics&) = delete;
 
    pacs_metrics(pacs_metrics&&) = delete;
    pacs_metrics& operator=(pacs_metrics&&) = delete;
 
    // =========================================================================
    // DIMSE Operation Recording
    // =========================================================================
 
    void record_store(bool success,
                      std::chrono::microseconds duration,
                      std::uint64_t bytes_stored = 0) noexcept {
        if (success) {
            c_store_.record_success(duration);
            if (bytes_stored > 0) {
                transfer_.add_bytes_received(bytes_stored);
                transfer_.increment_images_stored();
            }
        } else {
            c_store_.record_failure(duration);
        }
    }
 
    void record_query(bool success,
                      std::chrono::microseconds duration,
                      [[maybe_unused]] std::uint32_t matches = 0) noexcept {
        if (success) {
            c_find_.record_success(duration);
        } else {
            c_find_.record_failure(duration);
        }
    }
 
    void record_echo(bool success, std::chrono::microseconds duration) noexcept {
        if (success) {
            c_echo_.record_success(duration);
        } else {
            c_echo_.record_failure(duration);
        }
    }
 
    void record_move(bool success,
                     std::chrono::microseconds duration,
                     std::uint32_t images_moved = 0) noexcept {
        if (success) {
            c_move_.record_success(duration);
            for (std::uint32_t i = 0; i < images_moved; ++i) {
                transfer_.increment_images_retrieved();
            }
        } else {
            c_move_.record_failure(duration);
        }
    }
 
    void record_get(bool success,
                    std::chrono::microseconds duration,
                    std::uint32_t images_retrieved = 0,
                    std::uint64_t bytes_retrieved = 0) noexcept {
        if (success) {
            c_get_.record_success(duration);
            for (std::uint32_t i = 0; i < images_retrieved; ++i) {
                transfer_.increment_images_retrieved();
            }
            if (bytes_retrieved > 0) {
                transfer_.add_bytes_sent(bytes_retrieved);
            }
        } else {
            c_get_.record_failure(duration);
        }
    }
 
    void record_operation(dimse_operation op,
                          bool success,
                          std::chrono::microseconds duration) noexcept {
        auto& counter = get_counter(op);
        if (success) {
            counter.record_success(duration);
        } else {
            counter.record_failure(duration);
        }
    }
 
    // =========================================================================
    // Data Transfer Recording
    // =========================================================================
 
    void record_bytes_sent(std::uint64_t bytes) noexcept {
        transfer_.add_bytes_sent(bytes);
    }
 
    void record_bytes_received(std::uint64_t bytes) noexcept {
        transfer_.add_bytes_received(bytes);
    }
 
    // =========================================================================
    // Association Recording
    // =========================================================================
 
    void record_association_established() noexcept {
        associations_.record_established();
    }
 
    void record_association_released() noexcept {
        associations_.record_released();
    }
 
    void record_association_rejected() noexcept {
        associations_.record_rejected();
    }
 
    void record_association_aborted() noexcept {
        associations_.record_aborted();
    }
 
    // =========================================================================
    // Metric Access
    // =========================================================================
 
    [[nodiscard]] const operation_counter& get_counter(dimse_operation op) const noexcept {
        switch (op) {
            case dimse_operation::c_echo:
                return c_echo_;
            case dimse_operation::c_store:
                return c_store_;
            case dimse_operation::c_find:
                return c_find_;
            case dimse_operation::c_move:
                return c_move_;
            case dimse_operation::c_get:
                return c_get_;
            case dimse_operation::n_create:
                return n_create_;
            case dimse_operation::n_set:
                return n_set_;
            case dimse_operation::n_get:
                return n_get_;
            case dimse_operation::n_action:
                return n_action_;
            case dimse_operation::n_event:
                return n_event_;
            case dimse_operation::n_delete:
                return n_delete_;
            default:
                return c_echo_;  // Should never happen
        }
    }
 
    [[nodiscard]] operation_counter& get_counter(dimse_operation op) noexcept {
        return const_cast<operation_counter&>(
            static_cast<const pacs_metrics*>(this)->get_counter(op));
    }
 
    [[nodiscard]] const data_transfer_metrics& transfer() const noexcept {
        return transfer_;
    }
 
    [[nodiscard]] const association_counters& associations() const noexcept {
        return associations_;
    }
 
    // =========================================================================
    // Pool Metrics Access
    // =========================================================================
 
    [[nodiscard]] const pool_counters& element_pool() const noexcept {
        return element_pool_;
    }
 
    [[nodiscard]] pool_counters& element_pool() noexcept {
        return element_pool_;
    }
 
    [[nodiscard]] const pool_counters& dataset_pool() const noexcept {
        return dataset_pool_;
    }
 
    [[nodiscard]] pool_counters& dataset_pool() noexcept {
        return dataset_pool_;
    }
 
    [[nodiscard]] const pool_counters& pdu_buffer_pool() const noexcept {
        return pdu_buffer_pool_;
    }
 
    [[nodiscard]] pool_counters& pdu_buffer_pool() noexcept {
        return pdu_buffer_pool_;
    }
 
    // =========================================================================
    // Export Methods
    // =========================================================================
 
    [[nodiscard]] std::string to_json() const;
 
    [[nodiscard]] std::string to_prometheus(std::string_view prefix = "pacs") const;
 
    // =========================================================================
    // Reset
    // =========================================================================
 
    void reset() noexcept {
        c_echo_.reset();
        c_store_.reset();
        c_find_.reset();
        c_move_.reset();
        c_get_.reset();
        n_create_.reset();
        n_set_.reset();
        n_get_.reset();
        n_action_.reset();
        n_event_.reset();
        n_delete_.reset();
        transfer_.reset();
        associations_.reset();
        element_pool_.reset();
        dataset_pool_.reset();
        pdu_buffer_pool_.reset();
    }
 
private:
    // DIMSE operation counters
    operation_counter c_echo_;
    operation_counter c_store_;
    operation_counter c_find_;
    operation_counter c_move_;
    operation_counter c_get_;
    operation_counter n_create_;
    operation_counter n_set_;
    operation_counter n_get_;
    operation_counter n_action_;
    operation_counter n_event_;
    operation_counter n_delete_;
 
    // Data transfer metrics
    data_transfer_metrics transfer_;
 
    // Association lifecycle counters
    association_counters associations_;
 
    // Object pool metrics
    pool_counters element_pool_;
    pool_counters dataset_pool_;
    pool_counters pdu_buffer_pool_;
};
 
}  // namespace kcenon::pacs::monitoring