health_status.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 <chrono>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
namespace kcenon::pacs::monitoring {
 
enum class health_level {
    healthy,
 
    degraded,
 
    unhealthy
};
 
[[nodiscard]] constexpr std::string_view to_string(health_level level) noexcept {
    switch (level) {
        case health_level::healthy:
            return "healthy";
        case health_level::degraded:
            return "degraded";
        case health_level::unhealthy:
            return "unhealthy";
        default:
            return "unknown";
    }
}
 
struct database_status {
    bool connected{false};
 
    std::optional<std::chrono::system_clock::time_point> last_connected;
 
    std::uint32_t active_connections{0};
 
    std::optional<std::chrono::milliseconds> response_time;
 
    std::optional<std::string> error_message;
};
 
struct storage_status {
    bool writable{false};
 
    bool readable{false};
 
    std::uint64_t total_bytes{0};
 
    std::uint64_t used_bytes{0};
 
    std::uint64_t available_bytes{0};
 
    [[nodiscard]] double usage_percent() const noexcept {
        if (total_bytes == 0) {
            return 0.0;
        }
        return static_cast<double>(used_bytes) / static_cast<double>(total_bytes) *
               100.0;
    }
 
    std::optional<std::string> error_message;
};
 
struct association_metrics {
    std::uint32_t active_associations{0};
 
    std::uint32_t max_associations{100};
 
    std::uint64_t total_associations{0};
 
    std::uint64_t failed_associations{0};
};
 
struct storage_metrics {
    std::uint64_t total_instances{0};
 
    std::uint64_t total_studies{0};
 
    std::uint64_t total_series{0};
 
    std::uint64_t successful_stores{0};
 
    std::uint64_t failed_stores{0};
};
 
struct version_info {
    std::uint16_t major{1};
 
    std::uint16_t minor{0};
 
    std::uint16_t patch{0};
 
    std::string build_id;
 
    std::chrono::system_clock::time_point startup_time{
        std::chrono::system_clock::now()};
 
    [[nodiscard]] std::chrono::seconds uptime() const noexcept {
        return std::chrono::duration_cast<std::chrono::seconds>(
            std::chrono::system_clock::now() - startup_time);
    }
 
    [[nodiscard]] std::string version_string() const {
        return std::to_string(major) + "." + std::to_string(minor) + "." +
               std::to_string(patch);
    }
};
 
struct health_status {
    health_level level{health_level::unhealthy};
 
    std::chrono::system_clock::time_point timestamp{
        std::chrono::system_clock::now()};
 
    database_status database;
 
    storage_status storage;
 
    association_metrics associations;
 
    storage_metrics metrics;
 
    version_info version;
 
    std::optional<std::string> message;
 
    void update_level() noexcept {
        if (!database.connected) {
            level = health_level::unhealthy;
            return;
        }
 
        if (!storage.writable || !storage.readable) {
            level = health_level::unhealthy;
            return;
        }
 
        // Check for degraded conditions
        if (storage.usage_percent() > 90.0) {
            level = health_level::degraded;
            return;
        }
 
        if (associations.active_associations >=
            associations.max_associations * 0.9) {
            level = health_level::degraded;
            return;
        }
 
        level = health_level::healthy;
    }
 
    [[nodiscard]] bool is_healthy() const noexcept {
        return level == health_level::healthy;
    }
 
    [[nodiscard]] bool is_operational() const noexcept {
        return level != health_level::unhealthy;
    }
};
 
}  // namespace kcenon::pacs::monitoring