network_metric_event.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <chrono>
#include <map>
#include <string>
 
namespace kcenon::network::events {
 
enum class network_metric_type
{
    counter,   
    gauge,     
    histogram, 
    summary    
};
 
struct network_metric_event
{
    std::string name;                              
    double value;                                  
    std::string unit;                              
    network_metric_type type;                      
    std::chrono::steady_clock::time_point timestamp; 
    std::map<std::string, std::string> labels;     
    explicit network_metric_event(
        const std::string& metric_name,
        double metric_value,
        network_metric_type metric_type = network_metric_type::counter,
        const std::map<std::string, std::string>& metric_labels = {},
        const std::string& metric_unit = "")
        : name(metric_name)
        , value(metric_value)
        , unit(metric_unit)
        , type(metric_type)
        , timestamp(std::chrono::steady_clock::now())
        , labels(metric_labels)
    {
    }
 
    network_metric_event()
        : value(0.0)
        , type(network_metric_type::counter)
        , timestamp(std::chrono::steady_clock::now())
    {
    }
 
    network_metric_event(const network_metric_event&) = default;
 
    network_metric_event& operator=(const network_metric_event&) = default;
 
    network_metric_event(network_metric_event&&) noexcept = default;
 
    network_metric_event& operator=(network_metric_event&&) noexcept = default;
};
 
struct network_connection_event
{
    std::string connection_id;                     
    std::string event_type;                        
    std::string protocol;                          
    std::string remote_address;                    
    std::chrono::steady_clock::time_point timestamp;
    std::map<std::string, std::string> labels;
 
    explicit network_connection_event(
        const std::string& conn_id,
        const std::string& evt_type,
        const std::string& proto = "tcp",
        const std::string& remote = "",
        const std::map<std::string, std::string>& lbls = {})
        : connection_id(conn_id)
        , event_type(evt_type)
        , protocol(proto)
        , remote_address(remote)
        , timestamp(std::chrono::steady_clock::now())
        , labels(lbls)
    {
    }
 
    network_connection_event()
        : timestamp(std::chrono::steady_clock::now())
    {
    }
 
    network_connection_event(const network_connection_event&) = default;
    network_connection_event& operator=(const network_connection_event&) = default;
    network_connection_event(network_connection_event&&) noexcept = default;
    network_connection_event& operator=(network_connection_event&&) noexcept = default;
};
 
struct network_transfer_event
{
    std::string connection_id;                     
    std::string direction;                         
    std::size_t bytes;                             
    std::size_t packets;                           
    std::chrono::steady_clock::time_point timestamp;
    std::map<std::string, std::string> labels;
 
    explicit network_transfer_event(
        const std::string& conn_id,
        const std::string& dir,
        std::size_t byte_count,
        std::size_t packet_count = 1,
        const std::map<std::string, std::string>& lbls = {})
        : connection_id(conn_id)
        , direction(dir)
        , bytes(byte_count)
        , packets(packet_count)
        , timestamp(std::chrono::steady_clock::now())
        , labels(lbls)
    {
    }
 
    network_transfer_event()
        : bytes(0)
        , packets(0)
        , timestamp(std::chrono::steady_clock::now())
    {
    }
 
    network_transfer_event(const network_transfer_event&) = default;
    network_transfer_event& operator=(const network_transfer_event&) = default;
    network_transfer_event(network_transfer_event&&) noexcept = default;
    network_transfer_event& operator=(network_transfer_event&&) noexcept = default;
};
 
struct network_latency_event
{
    std::string connection_id;                     
    double latency_ms;                             
    std::string operation;                         
    std::chrono::steady_clock::time_point timestamp;
    std::map<std::string, std::string> labels;
 
    explicit network_latency_event(
        const std::string& conn_id,
        double latency,
        const std::string& op = "roundtrip",
        const std::map<std::string, std::string>& lbls = {})
        : connection_id(conn_id)
        , latency_ms(latency)
        , operation(op)
        , timestamp(std::chrono::steady_clock::now())
        , labels(lbls)
    {
    }
 
    network_latency_event()
        : latency_ms(0.0)
        , timestamp(std::chrono::steady_clock::now())
    {
    }
 
    network_latency_event(const network_latency_event&) = default;
    network_latency_event& operator=(const network_latency_event&) = default;
    network_latency_event(network_latency_event&&) noexcept = default;
    network_latency_event& operator=(network_latency_event&&) noexcept = default;
};
 
struct network_health_event
{
    std::string connection_id;                     
    bool is_alive;                                 
    double response_time_ms;                       
    std::size_t missed_heartbeats;                 
    double packet_loss_rate;                       
    std::chrono::steady_clock::time_point timestamp;
    std::map<std::string, std::string> labels;
 
    explicit network_health_event(
        const std::string& conn_id,
        bool alive,
        double response_time = 0.0,
        std::size_t missed = 0,
        double loss_rate = 0.0,
        const std::map<std::string, std::string>& lbls = {})
        : connection_id(conn_id)
        , is_alive(alive)
        , response_time_ms(response_time)
        , missed_heartbeats(missed)
        , packet_loss_rate(loss_rate)
        , timestamp(std::chrono::steady_clock::now())
        , labels(lbls)
    {
    }
 
    network_health_event()
        : is_alive(false)
        , response_time_ms(0.0)
        , missed_heartbeats(0)
        , packet_loss_rate(0.0)
        , timestamp(std::chrono::steady_clock::now())
    {
    }
 
    network_health_event(const network_health_event&) = default;
    network_health_event& operator=(const network_health_event&) = default;
    network_health_event(network_health_event&&) noexcept = default;
    network_health_event& operator=(network_health_event&&) noexcept = default;
};
 
} // namespace kcenon::network::events