kcenon::monitoring::zipkin_exporter Class Reference

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 464 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 475 of file trace_exporters.h.

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

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 478 of file trace_exporters.h.

        : 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 484 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;
    }

References config_, kcenon::monitoring::zipkin_span_data::duration, kcenon::monitoring::trace_span::end_time, kcenon::monitoring::zipkin_span_data::kind, kcenon::monitoring::zipkin_span_data::local_endpoint_service_name, kcenon::monitoring::zipkin_span_data::name, kcenon::monitoring::trace_span::operation_name, kcenon::monitoring::zipkin_span_data::parent_id, kcenon::monitoring::trace_span::parent_span_id, kcenon::monitoring::trace_export_config::service_name, kcenon::monitoring::trace_span::service_name, kcenon::monitoring::trace_span::span_id, kcenon::monitoring::zipkin_span_data::span_id, kcenon::monitoring::trace_span::start_time, kcenon::monitoring::trace_span::tags, kcenon::monitoring::zipkin_span_data::tags, kcenon::monitoring::zipkin_span_data::timestamp, kcenon::monitoring::trace_span::trace_id, and kcenon::monitoring::zipkin_span_data::trace_id.

Referenced by export_spans(), 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 517 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 553 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 562 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 571 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 600 of file trace_exporters.h.

                                                                                   {
        // Build protobuf payload
        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 + "/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::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 621 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 558 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 472 of file trace_exporters.h.

{100};

Referenced by send_with_retry().

config_

trace_export_config kcenon::monitoring::zipkin_exporter::config_

private

Definition at line 466 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 470 of file trace_exporters.h.

{0};

Referenced by get_stats().

exported_spans_

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

private

Definition at line 468 of file trace_exporters.h.

{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 469 of file trace_exporters.h.

{0};

Referenced by export_spans(), and get_stats().

max_retries_

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

private

Definition at line 471 of file trace_exporters.h.

{3};

Referenced by send_with_retry().

transport_

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

private

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