Jaeger-specific span representation. More...

#include <trace_exporters.h>

Collaboration diagram for kcenon::monitoring::jaeger_span_data:

Public Member Functions
std::string	to_thrift_json () const
	Convert to Jaeger Thrift format (JSON representation)

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

Public Attributes
std::string	trace_id

std::string	span_id

std::string	parent_span_id

std::string	operation_name

std::string	service_name

std::chrono::microseconds	start_time

std::chrono::microseconds	duration

std::vector< std::pair< std::string, std::string > >	tags

std::vector< std::pair< std::string, std::string > >	process_tags

Detailed Description

Jaeger-specific span representation.

Definition at line 106 of file trace_exporters.h.

Member Function Documentation

◆ to_protobuf()

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

inline

Convert this span to a Jaeger api_v2 Span protobuf message.

Field numbers follow jaeger-idl/proto/api_v2/model.proto. Trace IDs are zero-padded to 16 bytes and span IDs to 8 bytes, matching the conventions enforced by the Jaeger collector.

Definition at line 162 of file trace_exporters.h.

                                           {
        jaeger_proto::span out;
        out.trace_id = protobuf_wire::left_pad(
            protobuf_wire::hex_to_bytes(trace_id), 16);
        out.span_id = protobuf_wire::left_pad(
            protobuf_wire::hex_to_bytes(span_id), 8);
        out.operation_name = operation_name;
 
        if (!parent_span_id.empty()) {
            jaeger_proto::span_ref ref;
            ref.trace_id = out.trace_id;
            ref.span_id = protobuf_wire::left_pad(
                protobuf_wire::hex_to_bytes(parent_span_id), 8);
            ref.ref_type = 0;  // CHILD_OF
            out.references.push_back(std::move(ref));
        }
 
        // Timestamp / duration split into (seconds, nanos).
        auto st_ns = std::chrono::nanoseconds(start_time);
        out.start_time_seconds = static_cast<std::int64_t>(
            std::chrono::duration_cast<std::chrono::seconds>(st_ns).count());
        out.start_time_nanos = static_cast<std::int32_t>(
            (st_ns - std::chrono::seconds(out.start_time_seconds)).count());
 
        auto du_ns = std::chrono::nanoseconds(duration);
        out.duration_seconds = static_cast<std::int64_t>(
            std::chrono::duration_cast<std::chrono::seconds>(du_ns).count());
        out.duration_nanos = static_cast<std::int32_t>(
            (du_ns - std::chrono::seconds(out.duration_seconds)).count());
 
        for (const auto& [key, value] : tags) {
            jaeger_proto::key_value kv;
            kv.key = key;
            kv.v_type = jaeger_proto::value_type::string_type;
            kv.v_str = value;
            out.tags.push_back(std::move(kv));
        }
 
        out.proc.service_name = service_name;
        for (const auto& [key, value] : process_tags) {
            jaeger_proto::key_value kv;
            kv.key = key;
            kv.v_type = jaeger_proto::value_type::string_type;
            kv.v_str = value;
            out.proc.tags.push_back(std::move(kv));
        }
 
        return jaeger_proto::encode_span(out);
    }

Referenced by TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_thrift_json()

std::string kcenon::monitoring::jaeger_span_data::to_thrift_json ( ) const

inline

Convert to Jaeger Thrift format (JSON representation)

Definition at line 120 of file trace_exporters.h.

                                     {
        std::ostringstream json;
        json << "{";
        json << "\"traceIdHigh\":0,";
        json << "\"traceIdLow\":" << std::hash<std::string>{}(trace_id) << ",";
        json << "\"spanId\":" << std::hash<std::string>{}(span_id) << ",";
        json << "\"parentSpanId\":" << (parent_span_id.empty() ? "0" : std::to_string(std::hash<std::string>{}(parent_span_id))) << ",";
        json << "\"operationName\":\"" << operation_name << "\",";
        json << "\"startTime\":" << start_time.count() << ",";
        json << "\"duration\":" << duration.count() << ",";
 
        // Tags
        json << "\"tags\":[";
        bool first = true;
        for (const auto& [key, value] : tags) {
            if (!first) json << ",";
            json << "{\"key\":\"" << key << "\",\"vType\":\"STRING\",\"vStr\":\"" << value << "\"}";
            first = false;
        }
        json << "],";
 
        // Process
        json << "\"process\":{\"serviceName\":\"" << service_name << "\",\"tags\":[";
        first = true;
        for (const auto& [key, value] : process_tags) {
            if (!first) json << ",";
            json << "{\"key\":\"" << key << "\",\"vType\":\"STRING\",\"vStr\":\"" << value << "\"}";
            first = false;
        }
        json << "]}";
 
        json << "}";
        return json.str();
    }