dicom_collector_base.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 <mutex>
#include <string>
#include <unordered_map>
#include <vector>
 
namespace kcenon::pacs::monitoring {
 
using config_map = std::unordered_map<std::string, std::string>;
 
using stats_map = std::unordered_map<std::string, double>;
 
struct dicom_metric {
    std::string name;
    double value;
    std::string type;  // "gauge", "counter", "histogram"
    std::chrono::system_clock::time_point timestamp;
    std::unordered_map<std::string, std::string> tags;
 
    dicom_metric() : value(0.0), timestamp(std::chrono::system_clock::now()) {}
 
    dicom_metric(std::string n,
                 double v,
                 std::string t,
                 std::unordered_map<std::string, std::string> tgs = {})
        : name(std::move(n))
        , value(v)
        , type(std::move(t))
        , timestamp(std::chrono::system_clock::now())
        , tags(std::move(tgs)) {}
};
 
template <typename Derived>
class dicom_collector_base {
public:
    dicom_collector_base() = default;
    virtual ~dicom_collector_base() = default;
 
    // Non-copyable, non-moveable
    dicom_collector_base(const dicom_collector_base&) = delete;
    dicom_collector_base& operator=(const dicom_collector_base&) = delete;
    dicom_collector_base(dicom_collector_base&&) = delete;
    dicom_collector_base& operator=(dicom_collector_base&&) = delete;
 
    bool initialize(const config_map& config) {
        // Parse common configuration
        if (auto it = config.find("enabled"); it != config.end()) {
            enabled_ = (it->second == "true" || it->second == "1");
        }
 
        if (auto it = config.find("ae_title"); it != config.end()) {
            ae_title_ = it->second;
        }
 
        init_time_ = std::chrono::steady_clock::now();
 
        // Delegate to derived class for specific initialization
        return derived().do_initialize(config);
    }
 
    std::vector<dicom_metric> collect() {
        if (!enabled_) {
            return {};
        }
 
        try {
            auto metrics = derived().do_collect();
            ++collection_count_;
            last_collection_time_ = std::chrono::system_clock::now();
            return metrics;
        } catch (...) {
            ++collection_errors_;
            return {};
        }
    }
 
    [[nodiscard]] std::string get_name() const {
        return Derived::collector_name;
    }
 
    [[nodiscard]] std::vector<std::string> get_metric_types() const {
        return derived().do_get_metric_types();
    }
 
    [[nodiscard]] bool is_healthy() const {
        if (!enabled_) {
            return true;  // Disabled collectors are considered healthy
        }
        return derived().is_available();
    }
 
    [[nodiscard]] stats_map get_statistics() const {
        std::lock_guard<std::mutex> lock(stats_mutex_);
        stats_map stats;
 
        // Common statistics
        stats["enabled"] = enabled_ ? 1.0 : 0.0;
        stats["collection_count"] = static_cast<double>(collection_count_.load());
        stats["collection_errors"] = static_cast<double>(collection_errors_.load());
 
        // Uptime if initialized
        if (init_time_.time_since_epoch().count() > 0) {
            const auto uptime = std::chrono::duration_cast<std::chrono::seconds>(
                std::chrono::steady_clock::now() - init_time_);
            stats["uptime_seconds"] = static_cast<double>(uptime.count());
        }
 
        // Let derived class add specific statistics
        derived().do_add_statistics(stats);
 
        return stats;
    }
 
    [[nodiscard]] bool is_enabled() const { return enabled_; }
 
    [[nodiscard]] std::size_t get_collection_count() const {
        return collection_count_.load();
    }
 
    [[nodiscard]] std::size_t get_collection_errors() const {
        return collection_errors_.load();
    }
 
    [[nodiscard]] std::string get_ae_title() const { return ae_title_; }
 
    void set_ae_title(std::string ae_title) { ae_title_ = std::move(ae_title); }
 
protected:
    [[nodiscard]] 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 {
 
        std::unordered_map<std::string, std::string> tags = extra_tags;
        tags["collector"] = Derived::collector_name;
        if (!ae_title_.empty()) {
            tags["ae_title"] = ae_title_;
        }
 
        return dicom_metric(name, value, type, std::move(tags));
    }
 
    // Configuration
    bool enabled_{true};
    std::string ae_title_{"PACS_SCP"};
 
    // Statistics
    mutable std::mutex stats_mutex_;
    std::atomic<std::size_t> collection_count_{0};
    std::atomic<std::size_t> collection_errors_{0};
    std::chrono::steady_clock::time_point init_time_;
    std::chrono::system_clock::time_point last_collection_time_;
 
private:
    Derived& derived() { return static_cast<Derived&>(*this); }
    const Derived& derived() const { return static_cast<const Derived&>(*this); }
};
 
}  // namespace kcenon::pacs::monitoring