kcenon::monitoring::jaeger_exporter Class Reference

Jaeger trace exporter implementation. More...

#include <trace_exporters.h>

Inheritance diagram for kcenon::monitoring::jaeger_exporter:

Collaboration diagram for kcenon::monitoring::jaeger_exporter:

Public Member Functions
	jaeger_exporter (const trace_export_config &config)
	jaeger_exporter (const trace_export_config &config, std::unique_ptr< http_transport > transport)
jaeger_span_data	convert_span (const trace_span &span) const
	Convert internal span to Jaeger format.
common::VoidResult	export_spans (const std::vector< trace_span > &spans) override
	Export a batch of spans.
common::VoidResult	flush () override
	Flush any pending spans.
common::VoidResult	shutdown () override
	Shutdown the exporter.
std::unordered_map< std::string, std::size_t >	get_stats () const override
	Get exporter statistics.
Public Member Functions inherited from kcenon::monitoring::trace_exporter_interface
virtual	~trace_exporter_interface ()=default

Private Member Functions
common::VoidResult	send_thrift_batch (const std::vector< jaeger_span_data > &spans)
common::VoidResult	send_grpc_batch (const std::vector< jaeger_span_data > &spans)
common::VoidResult	send_with_retry (const http_request &request)

Private Attributes
trace_export_config	config_
std::unique_ptr< http_transport >	transport_
std::atomic< std::size_t >	exported_spans_ {0}
std::atomic< std::size_t >	failed_exports_ {0}
std::atomic< std::size_t >	dropped_spans_ {0}
std::size_t	max_retries_ {3}
std::chrono::milliseconds	base_retry_delay_ {100}

Detailed Description

Jaeger trace exporter implementation.

Supports both Thrift over HTTP and gRPC protocols. Default endpoint: /api/traces for Thrift HTTP

Definition at line 268 of file trace_exporters.h.

Constructor & Destructor Documentation

jaeger_exporter() [1/2]

kcenon::monitoring::jaeger_exporter::jaeger_exporter ( const trace_export_config & config )

inlineexplicit

Definition at line 279 of file trace_exporters.h.

        : config_(config), transport_(create_default_transport()) {}

jaeger_exporter() [2/2]

kcenon::monitoring::jaeger_exporter::jaeger_exporter ( const trace_export_config & config, std::unique_ptr< http_transport > transport )

inline

Definition at line 282 of file trace_exporters.h.

        : config_(config), transport_(std::move(transport)) {}

Member Function Documentation

convert_span()

jaeger_span_data kcenon::monitoring::jaeger_exporter::convert_span ( const trace_span & span ) const

inline

Convert internal span to Jaeger format.

Definition at line 288 of file trace_exporters.h.

                                                                {
        jaeger_span_data jaeger_span;
        jaeger_span.trace_id = span.trace_id;
        jaeger_span.span_id = span.span_id;
        jaeger_span.parent_span_id = span.parent_span_id;
        jaeger_span.operation_name = span.operation_name;
        jaeger_span.service_name = config_.service_name.value_or(span.service_name);
        
        // Convert timestamps
        auto start_epoch = span.start_time.time_since_epoch();
        jaeger_span.start_time = std::chrono::duration_cast<std::chrono::microseconds>(start_epoch);
        
        auto end_epoch = span.end_time.time_since_epoch();
        jaeger_span.duration = std::chrono::duration_cast<std::chrono::microseconds>(end_epoch - start_epoch);
        
        // Convert tags
        for (const auto& [key, value] : span.tags) {
            jaeger_span.tags.emplace_back(key, value);
        }
        
        // Add process tags
        jaeger_span.process_tags.emplace_back("service.name", jaeger_span.service_name);
        
        return jaeger_span;
    }

References config_, kcenon::monitoring::jaeger_span_data::duration, kcenon::monitoring::trace_span::end_time, kcenon::monitoring::jaeger_span_data::operation_name, kcenon::monitoring::trace_span::operation_name, kcenon::monitoring::jaeger_span_data::parent_span_id, kcenon::monitoring::trace_span::parent_span_id, kcenon::monitoring::jaeger_span_data::process_tags, kcenon::monitoring::jaeger_span_data::service_name, kcenon::monitoring::trace_export_config::service_name, kcenon::monitoring::trace_span::service_name, kcenon::monitoring::jaeger_span_data::span_id, kcenon::monitoring::trace_span::span_id, kcenon::monitoring::jaeger_span_data::start_time, kcenon::monitoring::trace_span::start_time, kcenon::monitoring::jaeger_span_data::tags, kcenon::monitoring::trace_span::tags, kcenon::monitoring::jaeger_span_data::trace_id, and kcenon::monitoring::trace_span::trace_id.

Referenced by export_spans(), and TEST_F().

Here is the caller graph for this function:

export_spans()

common::VoidResult kcenon::monitoring::jaeger_exporter::export_spans ( const std::vector< trace_span > & spans )

inlineoverridevirtual

Export a batch of spans.

Implements kcenon::monitoring::trace_exporter_interface.

Definition at line 314 of file trace_exporters.h.

                                                                               {
        try {
            std::vector<jaeger_span_data> jaeger_spans;
            jaeger_spans.reserve(spans.size());
 
            for (const auto& span : spans) {
                jaeger_spans.push_back(convert_span(span));
            }
 
            // Convert to appropriate format and send
            common::VoidResult send_result = common::ok();
            if (config_.format == trace_export_format::jaeger_thrift) {
                send_result = send_thrift_batch(jaeger_spans);
            } else if (config_.format == trace_export_format::jaeger_grpc) {
                send_result = send_grpc_batch(jaeger_spans);
            } else {
                return common::VoidResult::err(error_info(monitoring_error_code::invalid_configuration,
                                 "Invalid Jaeger export format", "monitoring_system").to_common_error());
            }
 
            if (send_result.is_ok()) {
                exported_spans_ += spans.size();
            } else {
                failed_exports_++;
                return send_result;
            }
 
            return common::ok();
 
        } catch (const std::exception& e) {
            failed_exports_++;
            return common::VoidResult::err(error_info(monitoring_error_code::operation_failed,
                             "Jaeger export failed: " + std::string(e.what()), "monitoring_system").to_common_error());
        }
    }

References config_, convert_span(), exported_spans_, failed_exports_, kcenon::monitoring::trace_export_config::format, kcenon::monitoring::invalid_configuration, kcenon::monitoring::jaeger_grpc, kcenon::monitoring::jaeger_thrift, kcenon::monitoring::operation_failed, send_grpc_batch(), send_thrift_batch(), and kcenon::monitoring::error_info::to_common_error().

Referenced by TEST_F(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

flush()

common::VoidResult kcenon::monitoring::jaeger_exporter::flush ( )

inlineoverridevirtual

Flush any pending spans.

Implements kcenon::monitoring::trace_exporter_interface.

Definition at line 350 of file trace_exporters.h.

                                      {
        // Jaeger exporter typically sends immediately, so flush is a no-op
        return common::ok();
    }

Referenced by shutdown(), and TEST_F().

Here is the caller graph for this function:

get_stats()

std::unordered_map< std::string, std::size_t > kcenon::monitoring::jaeger_exporter::get_stats ( ) const

inlineoverridevirtual

Get exporter statistics.

Implements kcenon::monitoring::trace_exporter_interface.

Definition at line 359 of file trace_exporters.h.

                                                                      {
        return {
            {"exported_spans", exported_spans_.load()},
            {"failed_exports", failed_exports_.load()},
            {"dropped_spans", dropped_spans_.load()}
        };
    }

References dropped_spans_, exported_spans_, and failed_exports_.

Referenced by TEST_F(), and TEST_F().

Here is the caller graph for this function:

send_grpc_batch()

common::VoidResult kcenon::monitoring::jaeger_exporter::send_grpc_batch ( const std::vector< jaeger_span_data > & spans )

inlineprivate

Definition at line 398 of file trace_exporters.h.

                                                                               {
        // gRPC would require a different transport mechanism
        // For now, fall back to HTTP POST with protobuf
        std::vector<uint8_t> payload;
        for (const auto& span : spans) {
            auto proto = span.to_protobuf();
            payload.insert(payload.end(), proto.begin(), proto.end());
        }
 
        http_request request;
        request.url = config_.endpoint;
        request.method = "POST";
        request.headers["Content-Type"] = "application/grpc+proto";
        for (const auto& [key, value] : config_.headers) {
            request.headers[key] = value;
        }
        request.body = payload;
        request.timeout = config_.timeout;
 
        return send_with_retry(request);
    }

References kcenon::monitoring::http_request::body, config_, kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::http_request::headers, kcenon::monitoring::trace_export_config::headers, kcenon::monitoring::http_request::method, send_with_retry(), kcenon::monitoring::http_request::timeout, kcenon::monitoring::trace_export_config::timeout, and kcenon::monitoring::http_request::url.

Referenced by export_spans().

Here is the call graph for this function:

Here is the caller graph for this function:

send_thrift_batch()

common::VoidResult kcenon::monitoring::jaeger_exporter::send_thrift_batch ( const std::vector< jaeger_span_data > & spans )

inlineprivate

Definition at line 368 of file trace_exporters.h.

                                                                                 {
        // Build JSON payload for Thrift over HTTP
        std::ostringstream payload;
        payload << "{\"data\":[{\"spans\":[";
        bool first = true;
        for (const auto& span : spans) {
            if (!first) payload << ",";
            payload << span.to_thrift_json();
            first = false;
        }
        payload << "]}]}";
 
        std::string body = payload.str();
 
        // Build HTTP request
        http_request request;
        request.url = config_.endpoint + "/api/traces";
        request.method = "POST";
        request.headers["Content-Type"] = "application/x-thrift";
        request.headers["Accept"] = "application/json";
        for (const auto& [key, value] : config_.headers) {
            request.headers[key] = value;
        }
        request.body = std::vector<uint8_t>(body.begin(), body.end());
        request.timeout = config_.timeout;
 
        // Send with retry
        return send_with_retry(request);
    }

References kcenon::monitoring::http_request::body, config_, kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::http_request::headers, kcenon::monitoring::trace_export_config::headers, kcenon::monitoring::http_request::method, send_with_retry(), kcenon::monitoring::http_request::timeout, kcenon::monitoring::trace_export_config::timeout, and kcenon::monitoring::http_request::url.

Referenced by export_spans().

Here is the call graph for this function:

Here is the caller graph for this function:

send_with_retry()

common::VoidResult kcenon::monitoring::jaeger_exporter::send_with_retry ( const http_request & request )

inlineprivate

Definition at line 420 of file trace_exporters.h.

                                                                  {
        std::size_t attempt = 0;
        std::chrono::milliseconds delay = base_retry_delay_;
 
        while (attempt < max_retries_) {
            auto result = transport_->send(request);
            if (result.is_ok()) {
                const auto& response = result.value();
                if (response.status_code >= 200 && response.status_code < 300) {
                    return common::ok();
                }
                // Retry on 5xx errors
                if (response.status_code >= 500) {
                    attempt++;
                    if (attempt < max_retries_) {
                        std::this_thread::sleep_for(delay);
                        delay *= 2; // Exponential backoff
                    }
                    continue;
                }
                // Non-retryable error
                return common::VoidResult::err(error_info(monitoring_error_code::operation_failed,
                    "Jaeger export failed with status: " + std::to_string(response.status_code),
                    "monitoring_system").to_common_error());
            }
            attempt++;
            if (attempt < max_retries_) {
                std::this_thread::sleep_for(delay);
                delay *= 2;
            }
        }
        return common::VoidResult::err(error_info(monitoring_error_code::operation_failed,
            "Jaeger export failed after " + std::to_string(max_retries_) + " retries",
            "monitoring_system").to_common_error());
    }

References base_retry_delay_, kcenon::monitoring::delay, max_retries_, kcenon::monitoring::operation_failed, kcenon::monitoring::error_info::to_common_error(), and transport_.

Referenced by send_grpc_batch(), and send_thrift_batch().

Here is the call graph for this function:

Here is the caller graph for this function:

shutdown()

common::VoidResult kcenon::monitoring::jaeger_exporter::shutdown ( )

inlineoverridevirtual

Shutdown the exporter.

Implements kcenon::monitoring::trace_exporter_interface.

Definition at line 355 of file trace_exporters.h.

                                         {
        return flush();
    }

References flush().

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

base_retry_delay_

std::chrono::milliseconds kcenon::monitoring::jaeger_exporter::base_retry_delay_ {100}

private

Definition at line 276 of file trace_exporters.h.

{100};

Referenced by send_with_retry().

config_

trace_export_config kcenon::monitoring::jaeger_exporter::config_

private

Definition at line 270 of file trace_exporters.h.

Referenced by convert_span(), export_spans(), send_grpc_batch(), and send_thrift_batch().

dropped_spans_

std::atomic<std::size_t> kcenon::monitoring::jaeger_exporter::dropped_spans_ {0}

private

Definition at line 274 of file trace_exporters.h.

{0};

Referenced by get_stats().

exported_spans_

std::atomic<std::size_t> kcenon::monitoring::jaeger_exporter::exported_spans_ {0}

private

Definition at line 272 of file trace_exporters.h.

{0};

Referenced by export_spans(), and get_stats().

failed_exports_

std::atomic<std::size_t> kcenon::monitoring::jaeger_exporter::failed_exports_ {0}

private

Definition at line 273 of file trace_exporters.h.

{0};

Referenced by export_spans(), and get_stats().

max_retries_

std::size_t kcenon::monitoring::jaeger_exporter::max_retries_ {3}

private

Definition at line 275 of file trace_exporters.h.

{3};

Referenced by send_with_retry().

transport_

std::unique_ptr<http_transport> kcenon::monitoring::jaeger_exporter::transport_

private

Definition at line 271 of file trace_exporters.h.

Referenced by send_with_retry().

---

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

• include/kcenon/monitoring/exporters/trace_exporters.h