Zipkin trace exporter implementation. More...

#include <trace_exporters.h>

Inheritance diagram for kcenon::monitoring::zipkin_exporter:

Collaboration diagram for kcenon::monitoring::zipkin_exporter:

Public Member Functions
	zipkin_exporter (const trace_export_config &config)

	zipkin_exporter (const trace_export_config &config, std::unique_ptr< http_transport > transport)

zipkin_span_data	convert_span (const trace_span &span) const
	Convert internal span to Zipkin 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_json_batch (const std::vector< zipkin_span_data > &spans)

common::VoidResult	send_protobuf_batch (const std::vector< zipkin_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

Zipkin trace exporter implementation.

Supports JSON v2 and Protocol Buffers formats. Default endpoint: /api/v2/spans

Definition at line 632 of file trace_exporters.h.

Constructor & Destructor Documentation

◆ zipkin_exporter() [1/2]

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

inlineexplicit

Definition at line 643 of file trace_exporters.h.

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

kcenon::monitoring::zipkin_exporter::transport_

std::unique_ptr< http_transport > transport_

Definition trace_exporters.h:635

kcenon::monitoring::zipkin_exporter::config_

trace_export_config config_

Definition trace_exporters.h:634

kcenon::monitoring::create_default_transport

std::unique_ptr< http_transport > create_default_transport()

Create default HTTP transport.

Definition http_transport.h:319

◆ zipkin_exporter() [2/2]

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

inline

Definition at line 646 of file trace_exporters.h.

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

Member Function Documentation

◆ convert_span()

zipkin_span_data kcenon::monitoring::zipkin_exporter::convert_span ( const trace_span & span ) const

inline

Convert internal span to Zipkin format.

Definition at line 652 of file trace_exporters.h.

                                                                {
        zipkin_span_data zipkin_span;
        zipkin_span.trace_id = span.trace_id;
        zipkin_span.span_id = span.span_id;
        zipkin_span.parent_id = span.parent_span_id;
        zipkin_span.name = span.operation_name;
        zipkin_span.local_endpoint_service_name = config_.service_name.value_or(span.service_name);
        
        // Convert timestamps (Zipkin uses microseconds since epoch)
        auto start_epoch = span.start_time.time_since_epoch();
        zipkin_span.timestamp = std::chrono::duration_cast<std::chrono::microseconds>(start_epoch);
        
        auto end_epoch = span.end_time.time_since_epoch();
        zipkin_span.duration = std::chrono::duration_cast<std::chrono::microseconds>(end_epoch - start_epoch);
        
        // Determine span kind from tags
        auto kind_it = span.tags.find("span.kind");
        if (kind_it != span.tags.end()) {
            zipkin_span.kind = kind_it->second;
        } else {
            zipkin_span.kind = "INTERNAL";
        }
        
        // Convert tags (exclude special fields)
        for (const auto& [key, value] : span.tags) {
            if (key != "span.kind") {
                zipkin_span.tags[key] = value;
            }
        }
        
        return zipkin_span;
    }

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

Here is the caller graph for this function:

◆ export_spans()

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

inlineoverridevirtual

Export a batch of spans.

Implements kcenon::monitoring::trace_exporter_interface.

Definition at line 685 of file trace_exporters.h.

                                                                               {
        try {
            std::vector<zipkin_span_data> zipkin_spans;
            zipkin_spans.reserve(spans.size());
 
            for (const auto& span : spans) {
                zipkin_spans.push_back(convert_span(span));
            }
 
            // Convert to appropriate format and send
            common::VoidResult send_result = common::ok();
            if (config_.format == trace_export_format::zipkin_json) {
                send_result = send_json_batch(zipkin_spans);
            } else if (config_.format == trace_export_format::zipkin_protobuf) {
                send_result = send_protobuf_batch(zipkin_spans);
            } else {
                return common::VoidResult::err(error_info(monitoring_error_code::invalid_configuration,
                                 "Invalid Zipkin 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,
                             "Zipkin 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::operation_failed, send_json_batch(), send_protobuf_batch(), kcenon::monitoring::error_info::to_common_error(), kcenon::monitoring::zipkin_json, and kcenon::monitoring::zipkin_protobuf.

Referenced by 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::zipkin_exporter::flush ( )

inlineoverridevirtual

Flush any pending spans.

Implements kcenon::monitoring::trace_exporter_interface.

Definition at line 721 of file trace_exporters.h.

                                      {
        // Zipkin 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::zipkin_exporter::get_stats ( ) const

inlineoverridevirtual

Get exporter statistics.

Implements kcenon::monitoring::trace_exporter_interface.

Definition at line 730 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().

Here is the caller graph for this function:

◆ send_json_batch()

common::VoidResult kcenon::monitoring::zipkin_exporter::send_json_batch ( const std::vector< zipkin_span_data > & spans )

inlineprivate

Definition at line 739 of file trace_exporters.h.

                                                                               {
        // Build JSON array payload for Zipkin v2 API
        std::ostringstream payload;
        payload << "[";
        bool first = true;
        for (const auto& span : spans) {
            if (!first) payload << ",";
            payload << span.to_json_v2();
            first = false;
        }
        payload << "]";
 
        std::string body = payload.str();
 
        // Build HTTP request
        http_request request;
        request.url = config_.endpoint + "/api/v2/spans";
        request.method = "POST";
        request.headers["Content-Type"] = "application/json";
        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;
 
        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_protobuf_batch()

common::VoidResult kcenon::monitoring::zipkin_exporter::send_protobuf_batch ( const std::vector< zipkin_span_data > & spans )

inlineprivate

Definition at line 768 of file trace_exporters.h.

                                                                                   {
        // Serialize as a Zipkin `ListOfSpans` protobuf message. POST target
        // accepts application/x-protobuf per Zipkin v2 API.
        auto payload = encode_zipkin_list_of_spans(spans);
 
        http_request request;
        request.url = config_.endpoint + "/api/v2/spans";
        request.method = "POST";
        request.headers["Content-Type"] = "application/x-protobuf";
        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::encode_zipkin_list_of_spans(), 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::zipkin_exporter::send_with_retry ( const http_request & request )

inlineprivate

Definition at line 786 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,
                    "Zipkin 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,
            "Zipkin 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_json_batch(), and send_protobuf_batch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ shutdown()

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

inlineoverridevirtual

Shutdown the exporter.

Implements kcenon::monitoring::trace_exporter_interface.

Definition at line 726 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::zipkin_exporter::base_retry_delay_ {100}

private

Definition at line 640 of file trace_exporters.h.

640{100};

Referenced by send_with_retry().

◆ config_

trace_export_config kcenon::monitoring::zipkin_exporter::config_

private

Definition at line 634 of file trace_exporters.h.

Referenced by convert_span(), export_spans(), send_json_batch(), and send_protobuf_batch().

◆ dropped_spans_

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

private

Definition at line 638 of file trace_exporters.h.

638{0};

Referenced by get_stats().

◆ exported_spans_

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

private

Definition at line 636 of file trace_exporters.h.

636{0};

Referenced by export_spans(), and get_stats().

◆ failed_exports_

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

private

Definition at line 637 of file trace_exporters.h.

637{0};

Referenced by export_spans(), and get_stats().

◆ max_retries_

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

private

Definition at line 639 of file trace_exporters.h.

639{3};

Referenced by send_with_retry().

◆ transport_

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

private

Definition at line 635 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

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ zipkin_exporter() [1/2]

◆ zipkin_exporter() [2/2]

Member Function Documentation

◆ convert_span()

◆ export_spans()

◆ flush()

◆ get_stats()

◆ send_json_batch()

◆ send_protobuf_batch()

◆ send_with_retry()

◆ shutdown()

Member Data Documentation

◆ base_retry_delay_

◆ config_

◆ dropped_spans_

◆ exported_spans_

◆ failed_exports_

◆ max_retries_

◆ transport_