kcenon::thread::diagnostics::health_status Struct Reference

Comprehensive health status of the thread pool. More...

#include <health_status.h>

Collaboration diagram for kcenon::thread::diagnostics::health_status:

Public Member Functions
auto	is_operational () const -> bool
	Checks if the thread pool is operational.
auto	is_healthy () const -> bool
	Checks if the thread pool is fully healthy.
auto	http_status_code () const -> int
	Gets HTTP status code for this health status.
auto	find_component (const std::string &name) const -> const component_health *
	Finds a component by name.
auto	calculate_overall_status () -> void
	Calculates overall status from component states.
auto	to_json () const -> std::string
	Converts health status to JSON string.
auto	to_string () const -> std::string
	Converts health status to human-readable string.
auto	to_prometheus (const std::string &pool_name="default") const -> std::string
	Converts health status to Prometheus-compatible metrics format.

Public Attributes
health_state	overall_status {health_state::unknown}
	Overall health state of the thread pool.
std::string	status_message
	Human-readable message about overall status.
std::chrono::steady_clock::time_point	check_time
	Time when this health check was performed.
std::vector< component_health >	components
	Health status of individual components.
double	uptime_seconds {0.0}
	Time since the thread pool was started (seconds).
std::uint64_t	total_jobs_processed {0}
	Total number of jobs processed since startup.
double	success_rate {1.0}
	Job success rate (0.0 to 1.0).
double	avg_latency_ms {0.0}
	Average job latency in milliseconds.
std::size_t	active_workers {0}
	Number of active workers.
std::size_t	total_workers {0}
	Total number of workers.
std::size_t	queue_depth {0}
	Current queue depth.
std::size_t	queue_capacity {0}
	Queue capacity (if bounded).

Detailed Description

Comprehensive health status of the thread pool.

Contains overall health status, individual component health, and summary metrics. Designed to be compatible with standard health check frameworks and easily serializable to JSON.

Health Check Integration

This structure is designed to integrate with:

• Kubernetes liveness/readiness probes
• Spring Boot Actuator style health endpoints
• Prometheus health metrics

Usage Example

auto health = pool->diagnostics().health_check();
if (health.overall_status == health_state::healthy) {
    return http_response(200, health.to_json());
} else {
    return http_response(health_state_to_http_code(health.overall_status),
                        health.to_json());
}

Definition at line 205 of file health_status.h.

Member Function Documentation

calculate_overall_status()

auto kcenon::thread::diagnostics::health_status::calculate_overall_status ( ) -> void

inline

Calculates overall status from component states.

Updates overall_status based on component health:

• If any unhealthy → unhealthy
• If any degraded → degraded
• If all healthy → healthy
• If empty → unknown

Definition at line 334 of file health_status.h.

        {
            if (components.empty())
            {
                overall_status = health_state::unknown;
                status_message = "No components registered";
                return;
            }
 
            bool has_unhealthy = false;
            bool has_degraded = false;
            bool has_unknown = false;
 
            for (const auto& comp : components)
            {
                switch (comp.state)
                {
                    case health_state::unhealthy:
                        has_unhealthy = true;
                        break;
                    case health_state::degraded:
                        has_degraded = true;
                        break;
                    case health_state::unknown:
                        has_unknown = true;
                        break;
                    default:
                        break;
                }
            }
 
            if (has_unhealthy)
            {
                overall_status = health_state::unhealthy;
                status_message = "One or more components are unhealthy";
            }
            else if (has_degraded)
            {
                overall_status = health_state::degraded;
                status_message = "One or more components are degraded";
            }
            else if (has_unknown)
            {
                overall_status = health_state::degraded;
                status_message = "One or more components have unknown status";
            }
            else
            {
                overall_status = health_state::healthy;
                status_message = "All components are healthy";
            }
        }

References components, kcenon::thread::diagnostics::degraded, kcenon::thread::diagnostics::healthy, overall_status, status_message, kcenon::thread::diagnostics::unhealthy, and kcenon::thread::diagnostics::unknown.

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check().

Here is the caller graph for this function:

find_component()

auto kcenon::thread::diagnostics::health_status::find_component ( const std::string & name ) const -> const component_health*

inlinenodiscard

Finds a component by name.

Parameters

name	Component name to search for.

Returns

Pointer to component health, or nullptr if not found.

Definition at line 312 of file health_status.h.

        {
            for (const auto& comp : components)
            {
                if (comp.name == name)
                {
                    return ∁
                }
            }
            return nullptr;
        }

References components.

http_status_code()

auto kcenon::thread::diagnostics::health_status::http_status_code ( ) const -> int

inlinenodiscard

Gets HTTP status code for this health status.

Returns

Appropriate HTTP status code.

Definition at line 302 of file health_status.h.

        {
            return health_state_to_http_code(overall_status);
        }

References kcenon::thread::diagnostics::health_state_to_http_code(), and overall_status.

Referenced by to_json(), and to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

is_healthy()

auto kcenon::thread::diagnostics::health_status::is_healthy ( ) const -> bool

inlinenodiscard

Checks if the thread pool is fully healthy.

Returns

true if overall status is healthy.

Definition at line 293 of file health_status.h.

        {
            return overall_status == health_state::healthy;
        }

References kcenon::thread::diagnostics::healthy, and overall_status.

is_operational()

auto kcenon::thread::diagnostics::health_status::is_operational ( ) const -> bool

inlinenodiscard

Checks if the thread pool is operational.

Returns

true if overall status is healthy or degraded.

Definition at line 283 of file health_status.h.

        {
            return overall_status == health_state::healthy ||
                   overall_status == health_state::degraded;
        }

References kcenon::thread::diagnostics::degraded, kcenon::thread::diagnostics::healthy, and overall_status.

to_json()

auto kcenon::thread::diagnostics::health_status::to_json ( ) const -> std::string

inlinenodiscard

Converts health status to JSON string.

Output format is compatible with standard health check endpoints and monitoring tools like Kubernetes, Spring Boot Actuator, etc.

Returns

JSON string representation of the health status.

Definition at line 399 of file health_status.h.

        {
            std::ostringstream oss;
            oss << std::fixed;
 
            oss << "{\n";
            oss << "  \"status\": \"" << health_state_to_string(overall_status) << "\",\n";
            oss << "  \"message\": \"" << status_message << "\",\n";
            oss << "  \"http_code\": " << http_status_code() << ",\n";
 
            // Metrics
            oss << "  \"metrics\": {\n";
            oss << "    \"uptime_seconds\": " << std::setprecision(2) << uptime_seconds << ",\n";
            oss << "    \"total_jobs_processed\": " << total_jobs_processed << ",\n";
            oss << "    \"success_rate\": " << std::setprecision(4) << success_rate << ",\n";
            oss << "    \"avg_latency_ms\": " << std::setprecision(3) << avg_latency_ms << "\n";
            oss << "  },\n";
 
            // Workers
            oss << "  \"workers\": {\n";
            oss << "    \"total\": " << total_workers << ",\n";
            oss << "    \"active\": " << active_workers << ",\n";
            oss << "    \"idle\": " << (total_workers - active_workers) << "\n";
            oss << "  },\n";
 
            // Queue
            oss << "  \"queue\": {\n";
            oss << "    \"depth\": " << queue_depth << ",\n";
            oss << "    \"capacity\": " << queue_capacity << "\n";
            oss << "  },\n";
 
            // Components
            oss << "  \"components\": [\n";
            for (std::size_t i = 0; i < components.size(); ++i)
            {
                const auto& comp = components[i];
                oss << "    {\n";
                oss << "      \"name\": \"" << comp.name << "\",\n";
                oss << "      \"status\": \"" << health_state_to_string(comp.state) << "\",\n";
                oss << "      \"message\": \"" << comp.message << "\"";
 
                if (!comp.details.empty())
                {
                    oss << ",\n      \"details\": {\n";
                    std::size_t detail_idx = 0;
                    for (const auto& [key, value] : comp.details)
                    {
                        oss << "        \"" << key << "\": \"" << value << "\"";
                        if (++detail_idx < comp.details.size())
                        {
                            oss << ",";
                        }
                        oss << "\n";
                    }
                    oss << "      }\n";
                }
                else
                {
                    oss << "\n";
                }
 
                oss << "    }";
                if (i < components.size() - 1)
                {
                    oss << ",";
                }
                oss << "\n";
            }
            oss << "  ]\n";
            oss << "}";
 
            return oss.str();
        }

References active_workers, avg_latency_ms, components, kcenon::thread::diagnostics::health_state_to_string(), http_status_code(), overall_status, queue_capacity, queue_depth, status_message, success_rate, total_jobs_processed, total_workers, and uptime_seconds.

Here is the call graph for this function:

to_prometheus()

auto kcenon::thread::diagnostics::health_status::to_prometheus ( const std::string & pool_name = "default" ) const -> std::string

inlinenodiscard

Converts health status to Prometheus-compatible metrics format.

Produces metrics in Prometheus exposition format suitable for scraping by Prometheus or compatible monitoring systems.

Parameters

pool_name

Name of the thread pool for metric labels.

Returns

Prometheus-formatted metrics string.

Output format:

# HELP thread_pool_health_status Health status (1=healthy, 0.5=degraded, 0=unhealthy)
# TYPE thread_pool_health_status gauge
thread_pool_health_status{pool="MyPool"} 1
# HELP thread_pool_uptime_seconds Total uptime in seconds
# TYPE thread_pool_uptime_seconds counter
thread_pool_uptime_seconds{pool="MyPool"} 3600.5

Definition at line 542 of file health_status.h.

        {
            std::ostringstream oss;
            oss << std::fixed;
 
            // Health status (1 = healthy, 0.5 = degraded, 0 = unhealthy/unknown)
            double health_value = 0.0;
            switch (overall_status)
            {
                case health_state::healthy: health_value = 1.0; break;
                case health_state::degraded: health_value = 0.5; break;
                default: health_value = 0.0; break;
            }
            oss << "# HELP thread_pool_health_status Health status (1=healthy, 0.5=degraded, 0=unhealthy)\n";
            oss << "# TYPE thread_pool_health_status gauge\n";
            oss << "thread_pool_health_status{pool=\"" << pool_name << "\"} "
                << std::setprecision(1) << health_value << "\n\n";
 
            // Uptime
            oss << "# HELP thread_pool_uptime_seconds Total uptime in seconds\n";
            oss << "# TYPE thread_pool_uptime_seconds counter\n";
            oss << "thread_pool_uptime_seconds{pool=\"" << pool_name << "\"} "
                << std::setprecision(2) << uptime_seconds << "\n\n";
 
            // Jobs processed
            oss << "# HELP thread_pool_jobs_total Total number of jobs processed\n";
            oss << "# TYPE thread_pool_jobs_total counter\n";
            oss << "thread_pool_jobs_total{pool=\"" << pool_name << "\"} "
                << total_jobs_processed << "\n\n";
 
            // Success rate
            oss << "# HELP thread_pool_success_rate Ratio of successful jobs (0.0 to 1.0)\n";
            oss << "# TYPE thread_pool_success_rate gauge\n";
            oss << "thread_pool_success_rate{pool=\"" << pool_name << "\"} "
                << std::setprecision(4) << success_rate << "\n\n";
 
            // Average latency
            oss << "# HELP thread_pool_latency_avg_ms Average job latency in milliseconds\n";
            oss << "# TYPE thread_pool_latency_avg_ms gauge\n";
            oss << "thread_pool_latency_avg_ms{pool=\"" << pool_name << "\"} "
                << std::setprecision(3) << avg_latency_ms << "\n\n";
 
            // Workers
            oss << "# HELP thread_pool_workers_total Total number of workers\n";
            oss << "# TYPE thread_pool_workers_total gauge\n";
            oss << "thread_pool_workers_total{pool=\"" << pool_name << "\"} "
                << total_workers << "\n\n";
 
            oss << "# HELP thread_pool_workers_active Number of active workers\n";
            oss << "# TYPE thread_pool_workers_active gauge\n";
            oss << "thread_pool_workers_active{pool=\"" << pool_name << "\"} "
                << active_workers << "\n\n";
 
            oss << "# HELP thread_pool_workers_idle Number of idle workers\n";
            oss << "# TYPE thread_pool_workers_idle gauge\n";
            oss << "thread_pool_workers_idle{pool=\"" << pool_name << "\"} "
                << (total_workers - active_workers) << "\n\n";
 
            // Queue
            oss << "# HELP thread_pool_queue_depth Current queue depth\n";
            oss << "# TYPE thread_pool_queue_depth gauge\n";
            oss << "thread_pool_queue_depth{pool=\"" << pool_name << "\"} "
                << queue_depth << "\n\n";
 
            if (queue_capacity > 0)
            {
                oss << "# HELP thread_pool_queue_capacity Maximum queue capacity\n";
                oss << "# TYPE thread_pool_queue_capacity gauge\n";
                oss << "thread_pool_queue_capacity{pool=\"" << pool_name << "\"} "
                    << queue_capacity << "\n\n";
 
                double saturation = static_cast<double>(queue_depth) /
                                    static_cast<double>(queue_capacity);
                oss << "# HELP thread_pool_queue_saturation Queue saturation ratio (0.0 to 1.0)\n";
                oss << "# TYPE thread_pool_queue_saturation gauge\n";
                oss << "thread_pool_queue_saturation{pool=\"" << pool_name << "\"} "
                    << std::setprecision(4) << saturation << "\n\n";
            }
 
            // Component health
            for (const auto& comp : components)
            {
                double comp_health = 0.0;
                switch (comp.state)
                {
                    case health_state::healthy: comp_health = 1.0; break;
                    case health_state::degraded: comp_health = 0.5; break;
                    default: comp_health = 0.0; break;
                }
                oss << "# HELP thread_pool_component_health Component health status\n";
                oss << "# TYPE thread_pool_component_health gauge\n";
                oss << "thread_pool_component_health{pool=\"" << pool_name
                    << "\",component=\"" << comp.name << "\"} "
                    << std::setprecision(1) << comp_health << "\n";
            }
 
            return oss.str();
        }

References active_workers, avg_latency_ms, components, kcenon::thread::diagnostics::degraded, kcenon::thread::diagnostics::healthy, overall_status, queue_capacity, queue_depth, success_rate, total_jobs_processed, total_workers, and uptime_seconds.

to_string()

auto kcenon::thread::diagnostics::health_status::to_string ( ) const -> std::string

inlinenodiscard

Converts health status to human-readable string.

Provides a formatted text representation suitable for logging or console output.

Returns

Human-readable string representation.

Definition at line 481 of file health_status.h.

        {
            std::ostringstream oss;
            oss << std::fixed;
 
            oss << "=== Health Status: " << health_state_to_string(overall_status)
                << " (HTTP " << http_status_code() << ") ===\n";
            oss << "Message: " << status_message << "\n\n";
 
            oss << "Metrics:\n";
            oss << "  Uptime: " << std::setprecision(1) << uptime_seconds << " seconds\n";
            oss << "  Jobs processed: " << total_jobs_processed << "\n";
            oss << "  Success rate: " << std::setprecision(1) << (success_rate * 100.0) << "%\n";
            oss << "  Avg latency: " << std::setprecision(2) << avg_latency_ms << " ms\n\n";
 
            oss << "Workers: " << active_workers << "/" << total_workers << " active";
            if (total_workers > 0)
            {
                oss << " (" << (total_workers - active_workers) << " idle)";
            }
            oss << "\n";
 
            oss << "Queue: " << queue_depth;
            if (queue_capacity > 0)
            {
                double saturation = static_cast<double>(queue_depth) /
                                    static_cast<double>(queue_capacity) * 100.0;
                oss << "/" << queue_capacity << " (" << std::setprecision(1)
                    << saturation << "% full)";
            }
            oss << "\n\n";
 
            oss << "Components:\n";
            for (const auto& comp : components)
            {
                oss << "  [" << health_state_to_string(comp.state) << "] "
                    << comp.name << ": " << comp.message << "\n";
            }
 
            return oss.str();
        }

References active_workers, avg_latency_ms, components, kcenon::thread::diagnostics::health_state_to_string(), http_status_code(), overall_status, queue_capacity, queue_depth, status_message, success_rate, total_jobs_processed, total_workers, and uptime_seconds.

Here is the call graph for this function:

Member Data Documentation

active_workers

std::size_t kcenon::thread::diagnostics::health_status::active_workers {0}

Number of active workers.

Definition at line 258 of file health_status.h.

{0};

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check(), to_json(), to_prometheus(), and to_string().

avg_latency_ms

double kcenon::thread::diagnostics::health_status::avg_latency_ms {0.0}

Average job latency in milliseconds.

Definition at line 253 of file health_status.h.

{0.0};

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check(), to_json(), to_prometheus(), and to_string().

check_time

std::chrono::steady_clock::time_point kcenon::thread::diagnostics::health_status::check_time

Time when this health check was performed.

Definition at line 224 of file health_status.h.

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check().

components

std::vector<component_health> kcenon::thread::diagnostics::health_status::components

Health status of individual components.

Definition at line 229 of file health_status.h.

Referenced by calculate_overall_status(), find_component(), kcenon::thread::diagnostics::thread_pool_diagnostics::health_check(), to_json(), to_prometheus(), and to_string().

overall_status

health_state kcenon::thread::diagnostics::health_status::overall_status {health_state::unknown}

Overall health state of the thread pool.

Aggregated from all component health states. If any component is unhealthy, overall is unhealthy. If any component is degraded, overall is degraded.

Definition at line 214 of file health_status.h.

{health_state::unknown};

Referenced by calculate_overall_status(), http_status_code(), is_healthy(), is_operational(), to_json(), to_prometheus(), and to_string().

queue_capacity

std::size_t kcenon::thread::diagnostics::health_status::queue_capacity {0}

Queue capacity (if bounded).

Definition at line 273 of file health_status.h.

{0};

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check(), to_json(), to_prometheus(), and to_string().

queue_depth

std::size_t kcenon::thread::diagnostics::health_status::queue_depth {0}

Current queue depth.

Definition at line 268 of file health_status.h.

{0};

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check(), to_json(), to_prometheus(), and to_string().

status_message

std::string kcenon::thread::diagnostics::health_status::status_message

Human-readable message about overall status.

Definition at line 219 of file health_status.h.

Referenced by calculate_overall_status(), to_json(), and to_string().

success_rate

double kcenon::thread::diagnostics::health_status::success_rate {1.0}

Job success rate (0.0 to 1.0).

Definition at line 248 of file health_status.h.

{1.0};

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check(), to_json(), to_prometheus(), and to_string().

total_jobs_processed

std::uint64_t kcenon::thread::diagnostics::health_status::total_jobs_processed {0}

Total number of jobs processed since startup.

Definition at line 243 of file health_status.h.

{0};

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check(), to_json(), to_prometheus(), and to_string().

total_workers

std::size_t kcenon::thread::diagnostics::health_status::total_workers {0}

Total number of workers.

Definition at line 263 of file health_status.h.

{0};

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check(), to_json(), to_prometheus(), and to_string().

uptime_seconds

double kcenon::thread::diagnostics::health_status::uptime_seconds {0.0}

Time since the thread pool was started (seconds).

Definition at line 238 of file health_status.h.

{0.0};

Referenced by kcenon::thread::diagnostics::thread_pool_diagnostics::health_check(), to_json(), to_prometheus(), and to_string().

---

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

• include/kcenon/thread/diagnostics/health_status.h