job_info.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <iomanip>
#include <optional>
#include <sstream>
#include <string>
#include <thread>
 
namespace kcenon::thread::diagnostics
{
    enum class job_status
    {
        pending,    
        running,    
        completed,  
        failed,     
        cancelled,  
        timed_out   
    };
 
    [[nodiscard]] inline auto job_status_to_string(job_status status) -> std::string
    {
        switch (status)
        {
            case job_status::pending: return "pending";
            case job_status::running: return "running";
            case job_status::completed: return "completed";
            case job_status::failed: return "failed";
            case job_status::cancelled: return "cancelled";
            case job_status::timed_out: return "timed_out";
            default: return "unknown";
        }
    }
 
    struct job_info
    {
        std::uint64_t job_id{0};
 
        std::string job_name;
 
        std::chrono::steady_clock::time_point enqueue_time;
 
        std::chrono::steady_clock::time_point start_time;
 
        std::optional<std::chrono::steady_clock::time_point> end_time;
 
        std::chrono::nanoseconds wait_time{0};
 
        std::chrono::nanoseconds execution_time{0};
 
        job_status status{job_status::pending};
 
        std::optional<std::string> error_message;
 
        std::thread::id executed_by;
 
        std::optional<std::string> stack_trace;
 
        [[nodiscard]] auto total_latency() const -> std::chrono::nanoseconds
        {
            return wait_time + execution_time;
        }
 
        [[nodiscard]] auto is_finished() const -> bool
        {
            return status == job_status::completed ||
                   status == job_status::failed ||
                   status == job_status::cancelled ||
                   status == job_status::timed_out;
        }
 
        [[nodiscard]] auto is_active() const -> bool
        {
            return status == job_status::pending ||
                   status == job_status::running;
        }
 
        [[nodiscard]] auto wait_time_ms() const -> double
        {
            return std::chrono::duration<double, std::milli>(wait_time).count();
        }
 
        [[nodiscard]] auto execution_time_ms() const -> double
        {
            return std::chrono::duration<double, std::milli>(execution_time).count();
        }
 
        [[nodiscard]] auto to_json() const -> std::string
        {
            std::ostringstream oss;
            oss << "{\n";
            oss << "  \"job_id\": " << job_id << ",\n";
            oss << "  \"job_name\": \"" << job_name << "\",\n";
            oss << "  \"status\": \"" << job_status_to_string(status) << "\",\n";
            oss << std::fixed << std::setprecision(3);
            oss << "  \"wait_time_ms\": " << wait_time_ms() << ",\n";
            oss << "  \"execution_time_ms\": " << execution_time_ms() << ",\n";
            oss << "  \"total_latency_ms\": "
                << std::chrono::duration<double, std::milli>(total_latency()).count() << ",\n";
 
            // Format thread_id as string
            std::ostringstream tid_oss;
            tid_oss << executed_by;
            oss << "  \"thread_id\": \"" << tid_oss.str() << "\"";
 
            if (error_message.has_value())
            {
                oss << ",\n  \"error_message\": \"" << error_message.value() << "\"";
            }
            else
            {
                oss << ",\n  \"error_message\": null";
            }
 
            if (stack_trace.has_value())
            {
                oss << ",\n  \"stack_trace\": \"" << stack_trace.value() << "\"";
            }
 
            oss << "\n}";
            return oss.str();
        }
 
        [[nodiscard]] auto to_string() const -> std::string
        {
            std::ostringstream oss;
 
            // First line: job id, name, status
            oss << "Job#" << job_id << " \"" << job_name << "\" ["
                << job_status_to_string(status) << "]\n";
 
            // Second line: timing info
            oss << std::fixed << std::setprecision(3);
            oss << "  Wait: " << wait_time_ms() << "ms, ";
            oss << "Exec: " << execution_time_ms() << "ms, ";
            oss << "Total: "
                << std::chrono::duration<double, std::milli>(total_latency()).count() << "ms\n";
 
            // Third line: thread info
            oss << "  Thread: " << executed_by;
 
            // Error info if present
            if (error_message.has_value())
            {
                oss << "\n  Error: " << error_message.value();
            }
 
            return oss.str();
        }
    };
 
} // namespace kcenon::thread::diagnostics