execution_event.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 <functional>
#include <iomanip>
#include <memory>
#include <optional>
#include <sstream>
#include <string>
#include <thread>
 
namespace kcenon::thread::diagnostics
{
    enum class event_type
    {
        enqueued,    
        dequeued,    
        started,     
        completed,   
        failed,      
        cancelled,   
        retried      
    };
 
    [[nodiscard]] inline auto event_type_to_string(event_type type) -> std::string
    {
        switch (type)
        {
            case event_type::enqueued: return "enqueued";
            case event_type::dequeued: return "dequeued";
            case event_type::started: return "started";
            case event_type::completed: return "completed";
            case event_type::failed: return "failed";
            case event_type::cancelled: return "cancelled";
            case event_type::retried: return "retried";
            default: return "unknown";
        }
    }
 
    struct job_execution_event
    {
        std::uint64_t event_id{0};
 
        std::uint64_t job_id{0};
 
        std::string job_name;
 
        event_type type{event_type::enqueued};
 
        std::chrono::steady_clock::time_point timestamp;
 
        std::chrono::system_clock::time_point system_timestamp;
 
        std::thread::id thread_id;
 
        std::size_t worker_id{0};
 
        // =========================================================================
        // Timing Information
        // =========================================================================
 
        std::chrono::nanoseconds wait_time{0};
 
        std::chrono::nanoseconds execution_time{0};
 
        // =========================================================================
        // Error Information
        // =========================================================================
 
        std::optional<int> error_code;
 
        std::optional<std::string> error_message;
 
        // =========================================================================
        // Utility Methods
        // =========================================================================
 
        [[nodiscard]] auto format_timestamp() const -> std::string
        {
            auto time_t = std::chrono::system_clock::to_time_t(system_timestamp);
            auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
                system_timestamp.time_since_epoch()) % 1000;
 
            char buffer[32];
            std::strftime(buffer, sizeof(buffer), "%Y-%m-%dT%H:%M:%S",
                          std::gmtime(&time_t));
 
            return std::string(buffer) + "." +
                   std::to_string(ms.count()) + "Z";
        }
 
        [[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 is_terminal() const -> bool
        {
            return type == event_type::completed ||
                   type == event_type::failed ||
                   type == event_type::cancelled;
        }
 
        [[nodiscard]] auto is_error() const -> bool
        {
            return type == event_type::failed ||
                   type == event_type::cancelled;
        }
 
        [[nodiscard]] auto to_json() const -> std::string
        {
            std::ostringstream oss;
            oss << "{\n";
            oss << "  \"event_id\": " << event_id << ",\n";
            oss << "  \"job_id\": " << job_id << ",\n";
            oss << "  \"job_name\": \"" << job_name << "\",\n";
            oss << "  \"type\": \"" << event_type_to_string(type) << "\",\n";
            oss << "  \"timestamp\": \"" << format_timestamp() << "\",\n";
 
            // Format thread_id as string
            std::ostringstream tid_oss;
            tid_oss << thread_id;
            oss << "  \"thread_id\": \"" << tid_oss.str() << "\",\n";
 
            oss << "  \"worker_id\": " << worker_id << ",\n";
            oss << std::fixed << std::setprecision(3);
            oss << "  \"wait_time_ms\": " << wait_time_ms() << ",\n";
            oss << "  \"execution_time_ms\": " << execution_time_ms();
 
            if (error_code.has_value())
            {
                oss << ",\n  \"error_code\": " << error_code.value();
            }
            else
            {
                oss << ",\n  \"error_code\": null";
            }
 
            if (error_message.has_value())
            {
                oss << ",\n  \"error_message\": \"" << error_message.value() << "\"";
            }
            else
            {
                oss << ",\n  \"error_message\": null";
            }
 
            oss << "\n}";
            return oss.str();
        }
 
        [[nodiscard]] auto to_string() const -> std::string
        {
            std::ostringstream oss;
 
            // First line: timestamp, event info, job info, type
            oss << "[" << format_timestamp() << "] ";
            oss << "Event#" << event_id << " ";
            oss << "job:" << job_name << "#" << job_id << " ";
            oss << "type:" << event_type_to_string(type) << "\n";
 
            // Second line: worker, thread, timing
            oss << "  worker:" << worker_id << " ";
            oss << "thread:" << thread_id << " ";
            oss << std::fixed << std::setprecision(3);
            oss << "wait:" << wait_time_ms() << "ms ";
            oss << "exec:" << execution_time_ms() << "ms";
 
            // Error info if present
            if (error_code.has_value() || error_message.has_value())
            {
                oss << "\n  error:";
                if (error_code.has_value())
                {
                    oss << " code=" << error_code.value();
                }
                if (error_message.has_value())
                {
                    oss << " msg=\"" << error_message.value() << "\"";
                }
            }
 
            return oss.str();
        }
    };
 
    class execution_event_listener
    {
    public:
        virtual ~execution_event_listener() = default;
 
        virtual void on_event(const job_execution_event& event) = 0;
    };
 
} // namespace kcenon::thread::diagnostics