health_check.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <array>
#include <chrono>
#include <functional>
#include <string>
#include <string_view>
#include <utility>
 
#include "../monitoring_interface.h"
#include "../../utils/enum_serialization.h"
 
namespace kcenon::common::interfaces {
 
enum class health_check_type {
    liveness,   // Basic alive check - is the service running?
    readiness,  // Ready to accept traffic?
    startup,    // Has the service completed initialization?
    dependency, // External dependency check (database, cache, etc.)
    custom      // User-defined health check type
};
 
}  // namespace kcenon::common::interfaces
 
namespace kcenon::common {
 
template<>
struct enum_traits<interfaces::health_check_type> {
    static constexpr auto values = std::array{
        std::pair{interfaces::health_check_type::liveness, std::string_view{"LIVENESS"}},
        std::pair{interfaces::health_check_type::readiness, std::string_view{"READINESS"}},
        std::pair{interfaces::health_check_type::startup, std::string_view{"STARTUP"}},
        std::pair{interfaces::health_check_type::dependency, std::string_view{"DEPENDENCY"}},
        std::pair{interfaces::health_check_type::custom, std::string_view{"CUSTOM"}},
    };
    static constexpr std::string_view module_name = "health_check";
};
 
}  // namespace kcenon::common
 
namespace kcenon::common::interfaces {
 
inline std::string to_string(health_check_type type) {
    return enum_to_string(type);
}
 
inline Result<health_check_type> health_check_type_from_string(const std::string& str) {
    return enum_from_string<health_check_type>(str);
}
 
class health_check {
public:
    health_check() = default;
    virtual ~health_check() = default;
 
    health_check(const health_check&) = delete;
    health_check& operator=(const health_check&) = delete;
    health_check(health_check&&) = delete;
    health_check& operator=(health_check&&) = delete;
 
    [[nodiscard]] virtual std::string get_name() const = 0;
 
    [[nodiscard]] virtual health_check_type get_type() const = 0;
 
    virtual health_check_result check() = 0;
 
    [[nodiscard]] virtual std::chrono::milliseconds get_timeout() const {
        return std::chrono::milliseconds{5000};
    }
 
    [[nodiscard]] virtual bool is_critical() const { return true; }
};
 
class lambda_health_check : public health_check {
public:
    using check_function = std::function<health_check_result()>;
 
    lambda_health_check(std::string name,
                        health_check_type type,
                        check_function check_fn,
                        bool critical = true,
                        std::chrono::milliseconds timeout = std::chrono::milliseconds{5000})
        : name_(std::move(name))
        , type_(type)
        , check_fn_(std::move(check_fn))
        , critical_(critical)
        , timeout_(timeout) {}
 
    [[nodiscard]] std::string get_name() const override { return name_; }
 
    [[nodiscard]] health_check_type get_type() const override { return type_; }
 
    health_check_result check() override {
        if (!check_fn_) {
            health_check_result result;
            result.status = health_status::unknown;
            result.message = "No check function configured";
            return result;
        }
        return check_fn_();
    }
 
    [[nodiscard]] std::chrono::milliseconds get_timeout() const override { return timeout_; }
 
    [[nodiscard]] bool is_critical() const override { return critical_; }
 
private:
    std::string name_;
    health_check_type type_;
    check_function check_fn_;
    bool critical_;
    std::chrono::milliseconds timeout_;
};
 
}  // namespace kcenon::common::interfaces