tracing_config.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 <functional>
#include <map>
#include <string>
 
namespace kcenon::network::tracing {
 
// Forward declarations
class span;
struct span_event;
 
enum class exporter_type
{
    none,      
    console,   
    otlp_grpc, 
    otlp_http, 
    jaeger,    
    zipkin     
};
 
enum class sampler_type
{
    always_on,    
    always_off,   
    trace_id,     
    parent_based  
};
 
struct batch_config
{
    size_t max_queue_size = 512;
 
    std::chrono::milliseconds schedule_delay{5000};
 
    size_t max_export_batch_size = 512;
 
    std::chrono::milliseconds export_timeout{30000};
};
 
struct otlp_config
{
    std::string endpoint;
 
    std::map<std::string, std::string> headers;
 
    std::chrono::milliseconds timeout{10000};
 
    bool insecure = false;
 
    std::string certificate_path;
};
 
struct tracing_config
{
    exporter_type exporter = exporter_type::none;
 
    std::string service_name = "network_system";
 
    std::string service_version;
 
    std::string service_namespace;
 
    std::string service_instance_id;
 
    std::map<std::string, std::string> resource_attributes;
 
    sampler_type sampler = sampler_type::always_on;
 
    double sample_rate = 1.0;
 
    otlp_config otlp;
 
    std::string jaeger_endpoint = "http://localhost:14268/api/traces";
 
    std::string zipkin_endpoint = "http://localhost:9411/api/v2/spans";
 
    batch_config batch;
 
    bool debug = false;
 
    [[nodiscard]] static auto console() -> tracing_config
    {
        tracing_config config;
        config.exporter = exporter_type::console;
        return config;
    }
 
    [[nodiscard]] static auto otlp_grpc(
        const std::string& endpoint = "http://localhost:4317") -> tracing_config
    {
        tracing_config config;
        config.exporter = exporter_type::otlp_grpc;
        config.otlp.endpoint = endpoint;
        return config;
    }
 
    [[nodiscard]] static auto otlp_http(
        const std::string& endpoint = "http://localhost:4318") -> tracing_config
    {
        tracing_config config;
        config.exporter = exporter_type::otlp_http;
        config.otlp.endpoint = endpoint;
        return config;
    }
 
    [[nodiscard]] static auto jaeger(
        const std::string& endpoint = "http://localhost:14268/api/traces")
        -> tracing_config
    {
        tracing_config config;
        config.exporter = exporter_type::jaeger;
        config.jaeger_endpoint = endpoint;
        return config;
    }
 
    [[nodiscard]] static auto disabled() -> tracing_config
    {
        return tracing_config{};
    }
};
 
using span_processor_callback = std::function<void(const span&)>;
 
void configure_tracing(const tracing_config& config);
 
void shutdown_tracing();
 
void flush_tracing();
 
[[nodiscard]] auto is_tracing_enabled() -> bool;
 
void register_span_processor(span_processor_callback callback);
 
void export_span(const span& s);
 
} // namespace kcenon::network::tracing