Zipkin-specific span representation. More...

#include <trace_exporters.h>

Collaboration diagram for kcenon::monitoring::zipkin_span_data:

Public Member Functions
std::string	to_json_v2 () const
	Convert to Zipkin JSON v2 format.

std::vector< uint8_t >	to_protobuf () const
	Convert this span to a Zipkin `Span` protobuf message.

Public Attributes
std::string	trace_id

std::string	span_id

std::string	parent_id

std::string	name

std::string	kind

std::chrono::microseconds	timestamp

std::chrono::microseconds	duration

std::string	local_endpoint_service_name

std::string	remote_endpoint_service_name

std::unordered_map< std::string, std::string >	tags

bool	shared = false

Detailed Description

Zipkin-specific span representation.

Definition at line 265 of file trace_exporters.h.

Member Function Documentation

◆ to_json_v2()

std::string kcenon::monitoring::zipkin_span_data::to_json_v2 ( ) const

inline

Convert to Zipkin JSON v2 format.

Definition at line 281 of file trace_exporters.h.

                                 {
        std::ostringstream json;
        json << "{";
        json << "\"traceId\":\"" << trace_id << "\",";
        json << "\"id\":\"" << span_id << "\",";
        if (!parent_id.empty()) {
            json << "\"parentId\":\"" << parent_id << "\",";
        }
        json << "\"name\":\"" << name << "\",";
        json << "\"kind\":\"" << kind << "\",";
        json << "\"timestamp\":" << timestamp.count() << ",";
        json << "\"duration\":" << duration.count() << ",";
 
        // Local endpoint
        json << "\"localEndpoint\":{\"serviceName\":\"" << local_endpoint_service_name << "\"},";
 
        // Remote endpoint (if set)
        if (!remote_endpoint_service_name.empty()) {
            json << "\"remoteEndpoint\":{\"serviceName\":\"" << remote_endpoint_service_name << "\"},";
        }
 
        // Tags
        json << "\"tags\":{";
        bool first = true;
        for (const auto& [key, value] : tags) {
            if (!first) json << ",";
            json << "\"" << key << "\":\"" << value << "\"";
            first = false;
        }
        json << "}";
 
        if (shared) {
            json << ",\"shared\":true";
        }
 
        json << "}";
        return json.str();
    }

References duration, kind, local_endpoint_service_name, name, parent_id, remote_endpoint_service_name, shared, span_id, tags, timestamp, and trace_id.

◆ to_protobuf()

std::vector< uint8_t > kcenon::monitoring::zipkin_span_data::to_protobuf ( ) const

inline

Convert this span to a Zipkin Span protobuf message.

Field numbers follow openzipkin/zipkin-api/zipkin.proto. Trace IDs are expected to be 8 or 16 hex bytes; shorter inputs are zero-padded.

Definition at line 326 of file trace_exporters.h.

                                           {
        zipkin_proto::span out;
        auto trace_bytes = protobuf_wire::hex_to_bytes(trace_id);
        // Zipkin accepts 8 or 16 byte trace IDs; normalize the common
        // shorter/empty/non-hex inputs to 8 bytes so the wire always carries
        // a valid ID (Zipkin rejects spans without a trace ID).
        if (trace_bytes.size() == 16) {
            out.trace_id = std::move(trace_bytes);
        } else {
            out.trace_id = protobuf_wire::left_pad(trace_bytes, 8);
        }
        out.id = protobuf_wire::left_pad(
            protobuf_wire::hex_to_bytes(span_id), 8);
        if (!parent_id.empty()) {
            out.parent_id = protobuf_wire::left_pad(
                protobuf_wire::hex_to_bytes(parent_id), 8);
        }
        out.kind = zipkin_proto::parse_kind(kind);
        out.name = name;
        out.timestamp = static_cast<std::uint64_t>(timestamp.count());
        out.duration = static_cast<std::uint64_t>(duration.count());
        out.local_endpoint.service_name = local_endpoint_service_name;
        out.remote_endpoint.service_name = remote_endpoint_service_name;
        out.shared = shared;
        for (const auto& [key, value] : tags) {
            out.tags.emplace_back(key, value);
        }
        return zipkin_proto::encode_span(out);
    }