kcenon::monitoring::zipkin_proto Namespace Reference

Classes
struct	annotation
struct	endpoint
struct	list_of_spans
struct	span

Enumerations
enum class	span_kind : std::int32_t {   unspecified = 0 , client = 1 , server = 2 , producer = 3 ,   consumer = 4 }

Functions
span_kind	parse_kind (const std::string &value)
	Convert a textual Zipkin kind (e.g. "CLIENT") to its enum value.
std::vector< std::uint8_t >	encode_endpoint (const endpoint &ep)
std::vector< std::uint8_t >	encode_annotation (const annotation &ann)
std::vector< std::uint8_t >	encode_string_map_entry (const std::string &key, const std::string &value)
	Encode a single entry of a map<string,string> field.
std::vector< std::uint8_t >	encode_span (const span &s)
std::vector< std::uint8_t >	encode_list_of_spans (const list_of_spans &list)
bool	decode_endpoint (const std::uint8_t *data, std::size_t size, endpoint &out)
bool	decode_annotation (const std::uint8_t *data, std::size_t size, annotation &out)
bool	decode_map_entry (const std::uint8_t *data, std::size_t size, std::string &key, std::string &value)
bool	decode_span (const std::uint8_t *data, std::size_t size, span &out)
bool	decode_list_of_spans (const std::uint8_t *data, std::size_t size, list_of_spans &out)

Enumeration Type Documentation

span_kind

enum class kcenon::monitoring::zipkin_proto::span_kind : std::int32_t

strong

Enumerator
unspecified
client
server
producer
consumer

Definition at line 32 of file zipkin_proto.h.

                     : std::int32_t {
    unspecified = 0,
    client      = 1,
    server      = 2,
    producer    = 3,
    consumer    = 4,
};

Function Documentation

decode_annotation()

bool kcenon::monitoring::zipkin_proto::decode_annotation ( const std::uint8_t * data, std::size_t size, annotation & out )

inline

Definition at line 205 of file zipkin_proto.h.

                                               {
    protobuf_wire::reader r(data, size);
    while (!r.eof()) {
        std::uint32_t field_number;
        protobuf_wire::wire_type wt;
        if (!protobuf_wire::decode_tag(r, field_number, wt)) return false;
        switch (field_number) {
            case 1: {
                if (wt != protobuf_wire::wire_type::fixed64) return false;
                auto v = r.read_fixed64();
                if (!v) return false;
                out.timestamp = *v;
                break;
            }
            case 2:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_string(out.value)) return false;
                break;
            default:
                if (!r.skip_field(wt)) return false;
        }
    }
    return true;
}

References kcenon::monitoring::protobuf_wire::decode_tag(), kcenon::monitoring::protobuf_wire::reader::eof(), kcenon::monitoring::protobuf_wire::fixed64, kcenon::monitoring::protobuf_wire::length_delimited, kcenon::monitoring::protobuf_wire::reader::read_fixed64(), kcenon::monitoring::protobuf_wire::reader::read_string(), kcenon::monitoring::protobuf_wire::reader::skip_field(), kcenon::monitoring::zipkin_proto::annotation::timestamp, and kcenon::monitoring::zipkin_proto::annotation::value.

Referenced by decode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_endpoint()

bool kcenon::monitoring::zipkin_proto::decode_endpoint ( const std::uint8_t * data, std::size_t size, endpoint & out )

inline

Definition at line 171 of file zipkin_proto.h.

                                           {
    protobuf_wire::reader r(data, size);
    while (!r.eof()) {
        std::uint32_t field_number;
        protobuf_wire::wire_type wt;
        if (!protobuf_wire::decode_tag(r, field_number, wt)) return false;
        switch (field_number) {
            case 1:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_string(out.service_name)) return false;
                break;
            case 2:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_bytes(out.ipv4)) return false;
                break;
            case 3:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_bytes(out.ipv6)) return false;
                break;
            case 4: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.port = static_cast<std::int32_t>(*v);
                break;
            }
            default:
                if (!r.skip_field(wt)) return false;
        }
    }
    return true;
}

References kcenon::monitoring::protobuf_wire::decode_tag(), kcenon::monitoring::protobuf_wire::reader::eof(), kcenon::monitoring::zipkin_proto::endpoint::ipv4, kcenon::monitoring::zipkin_proto::endpoint::ipv6, kcenon::monitoring::protobuf_wire::length_delimited, kcenon::monitoring::zipkin_proto::endpoint::port, kcenon::monitoring::protobuf_wire::reader::read_bytes(), kcenon::monitoring::protobuf_wire::reader::read_string(), kcenon::monitoring::protobuf_wire::reader::read_varint(), kcenon::monitoring::zipkin_proto::endpoint::service_name, kcenon::monitoring::protobuf_wire::reader::skip_field(), and kcenon::monitoring::protobuf_wire::varint.

Referenced by decode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_list_of_spans()

bool kcenon::monitoring::zipkin_proto::decode_list_of_spans ( const std::uint8_t * data, std::size_t size, list_of_spans & out )

inline

Definition at line 351 of file zipkin_proto.h.

                                                     {
    protobuf_wire::reader r(data, size);
    while (!r.eof()) {
        std::uint32_t field_number;
        protobuf_wire::wire_type wt;
        if (!protobuf_wire::decode_tag(r, field_number, wt)) return false;
        if (field_number == 1 && wt == protobuf_wire::wire_type::length_delimited) {
            const std::uint8_t* ptr; std::size_t len;
            if (!r.read_length_delimited(&ptr, &len)) return false;
            span s;
            if (!decode_span(ptr, len, s)) return false;
            out.spans.push_back(std::move(s));
        } else {
            if (!r.skip_field(wt)) return false;
        }
    }
    return true;
}

References decode_span(), kcenon::monitoring::protobuf_wire::decode_tag(), kcenon::monitoring::protobuf_wire::reader::eof(), kcenon::monitoring::protobuf_wire::length_delimited, kcenon::monitoring::protobuf_wire::reader::read_length_delimited(), kcenon::monitoring::protobuf_wire::reader::skip_field(), and kcenon::monitoring::zipkin_proto::list_of_spans::spans.

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_map_entry()

bool kcenon::monitoring::zipkin_proto::decode_map_entry ( const std::uint8_t * data, std::size_t size, std::string & key, std::string & value )

inline

Definition at line 231 of file zipkin_proto.h.

                                                               {
    protobuf_wire::reader r(data, size);
    while (!r.eof()) {
        std::uint32_t field_number;
        protobuf_wire::wire_type wt;
        if (!protobuf_wire::decode_tag(r, field_number, wt)) return false;
        if (wt != protobuf_wire::wire_type::length_delimited) {
            if (!r.skip_field(wt)) return false;
            continue;
        }
        if (field_number == 1) {
            if (!r.read_string(key)) return false;
        } else if (field_number == 2) {
            if (!r.read_string(value)) return false;
        } else {
            const std::uint8_t* ptr; std::size_t len;
            if (!r.read_length_delimited(&ptr, &len)) return false;
        }
    }
    return true;
}

References kcenon::monitoring::protobuf_wire::decode_tag(), kcenon::monitoring::protobuf_wire::reader::eof(), kcenon::monitoring::protobuf_wire::length_delimited, kcenon::monitoring::protobuf_wire::reader::read_length_delimited(), kcenon::monitoring::protobuf_wire::reader::read_string(), and kcenon::monitoring::protobuf_wire::reader::skip_field().

Referenced by decode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

decode_span()

bool kcenon::monitoring::zipkin_proto::decode_span ( const std::uint8_t * data, std::size_t size, span & out )

inline

Definition at line 254 of file zipkin_proto.h.

                                                                           {
    protobuf_wire::reader r(data, size);
    while (!r.eof()) {
        std::uint32_t field_number;
        protobuf_wire::wire_type wt;
        if (!protobuf_wire::decode_tag(r, field_number, wt)) return false;
        switch (field_number) {
            case 1:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_bytes(out.trace_id)) return false;
                break;
            case 2:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_bytes(out.parent_id)) return false;
                break;
            case 3:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_bytes(out.id)) return false;
                break;
            case 4: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.kind = static_cast<span_kind>(*v);
                break;
            }
            case 5:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_string(out.name)) return false;
                break;
            case 6: {
                if (wt != protobuf_wire::wire_type::fixed64) return false;
                auto v = r.read_fixed64();
                if (!v) return false;
                out.timestamp = *v;
                break;
            }
            case 7: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.duration = *v;
                break;
            }
            case 8: {
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                const std::uint8_t* ptr; std::size_t len;
                if (!r.read_length_delimited(&ptr, &len)) return false;
                if (!decode_endpoint(ptr, len, out.local_endpoint)) return false;
                break;
            }
            case 9: {
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                const std::uint8_t* ptr; std::size_t len;
                if (!r.read_length_delimited(&ptr, &len)) return false;
                if (!decode_endpoint(ptr, len, out.remote_endpoint)) return false;
                break;
            }
            case 10: {
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                const std::uint8_t* ptr; std::size_t len;
                if (!r.read_length_delimited(&ptr, &len)) return false;
                annotation ann;
                if (!decode_annotation(ptr, len, ann)) return false;
                out.annotations.push_back(std::move(ann));
                break;
            }
            case 11: {
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                const std::uint8_t* ptr; std::size_t len;
                if (!r.read_length_delimited(&ptr, &len)) return false;
                std::string key, value;
                if (!decode_map_entry(ptr, len, key, value)) return false;
                out.tags.emplace_back(std::move(key), std::move(value));
                break;
            }
            case 12: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.debug = (*v != 0);
                break;
            }
            case 13: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.shared = (*v != 0);
                break;
            }
            default:
                if (!r.skip_field(wt)) return false;
        }
    }
    return true;
}

References kcenon::monitoring::zipkin_proto::span::annotations, kcenon::monitoring::zipkin_proto::span::debug, decode_annotation(), decode_endpoint(), decode_map_entry(), kcenon::monitoring::protobuf_wire::decode_tag(), kcenon::monitoring::zipkin_proto::span::duration, kcenon::monitoring::protobuf_wire::reader::eof(), kcenon::monitoring::protobuf_wire::fixed64, kcenon::monitoring::zipkin_proto::span::id, kcenon::monitoring::zipkin_proto::span::kind, kcenon::monitoring::protobuf_wire::length_delimited, kcenon::monitoring::zipkin_proto::span::local_endpoint, kcenon::monitoring::zipkin_proto::span::name, kcenon::monitoring::zipkin_proto::span::parent_id, kcenon::monitoring::protobuf_wire::reader::read_bytes(), kcenon::monitoring::protobuf_wire::reader::read_fixed64(), kcenon::monitoring::protobuf_wire::reader::read_length_delimited(), kcenon::monitoring::protobuf_wire::reader::read_string(), kcenon::monitoring::protobuf_wire::reader::read_varint(), kcenon::monitoring::zipkin_proto::span::remote_endpoint, kcenon::monitoring::zipkin_proto::span::shared, kcenon::monitoring::protobuf_wire::reader::skip_field(), kcenon::monitoring::zipkin_proto::span::tags, kcenon::monitoring::zipkin_proto::span::timestamp, kcenon::monitoring::zipkin_proto::span::trace_id, and kcenon::monitoring::protobuf_wire::varint.

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

Here is the call graph for this function:

Here is the caller graph for this function:

encode_annotation()

std::vector< std::uint8_t > kcenon::monitoring::zipkin_proto::encode_annotation ( const annotation & ann )

inline

Definition at line 104 of file zipkin_proto.h.

                                                                      {
    std::vector<std::uint8_t> out;
    if (ann.timestamp != 0) {
        protobuf_wire::encode_tag(out, 1, protobuf_wire::wire_type::fixed64);
        protobuf_wire::encode_fixed64(out, ann.timestamp);
    }
    protobuf_wire::encode_string_field(out, 2, ann.value);
    return out;
}

References kcenon::monitoring::protobuf_wire::encode_fixed64(), kcenon::monitoring::protobuf_wire::encode_string_field(), kcenon::monitoring::protobuf_wire::encode_tag(), kcenon::monitoring::protobuf_wire::fixed64, kcenon::monitoring::zipkin_proto::annotation::timestamp, and kcenon::monitoring::zipkin_proto::annotation::value.

Referenced by encode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_endpoint()

std::vector< std::uint8_t > kcenon::monitoring::zipkin_proto::encode_endpoint ( const endpoint & ep )

inline

Definition at line 95 of file zipkin_proto.h.

                                                                 {
    std::vector<std::uint8_t> out;
    protobuf_wire::encode_string_field(out, 1, ep.service_name);
    protobuf_wire::encode_bytes_field(out, 2, ep.ipv4);
    protobuf_wire::encode_bytes_field(out, 3, ep.ipv6);
    protobuf_wire::encode_uint64_field(out, 4, static_cast<std::uint64_t>(ep.port));
    return out;
}

References kcenon::monitoring::protobuf_wire::encode_bytes_field(), kcenon::monitoring::protobuf_wire::encode_string_field(), kcenon::monitoring::protobuf_wire::encode_uint64_field(), kcenon::monitoring::zipkin_proto::endpoint::ipv4, kcenon::monitoring::zipkin_proto::endpoint::ipv6, kcenon::monitoring::zipkin_proto::endpoint::port, and kcenon::monitoring::zipkin_proto::endpoint::service_name.

Referenced by encode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_list_of_spans()

std::vector< std::uint8_t > kcenon::monitoring::zipkin_proto::encode_list_of_spans ( const list_of_spans & list )

inline

Definition at line 158 of file zipkin_proto.h.

                                                                             {
    std::vector<std::uint8_t> out;
    for (const auto& s : list.spans) {
        auto serialized = encode_span(s);
        protobuf_wire::encode_message_field(out, 1, serialized);
    }
    return out;
}

References kcenon::monitoring::protobuf_wire::encode_message_field(), encode_span(), and kcenon::monitoring::zipkin_proto::list_of_spans::spans.

Referenced by kcenon::monitoring::encode_zipkin_list_of_spans().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_span()

std::vector< std::uint8_t > kcenon::monitoring::zipkin_proto::encode_span ( const span & s )

inline

Definition at line 128 of file zipkin_proto.h.

                                                        {
    std::vector<std::uint8_t> out;
    protobuf_wire::encode_bytes_field(out, 1, s.trace_id);
    protobuf_wire::encode_bytes_field(out, 2, s.parent_id);
    protobuf_wire::encode_bytes_field(out, 3, s.id);
    protobuf_wire::encode_enum_field(out, 4, static_cast<std::int32_t>(s.kind));
    protobuf_wire::encode_string_field(out, 5, s.name);
    protobuf_wire::encode_fixed64_field(out, 6, s.timestamp);
    protobuf_wire::encode_uint64_field(out, 7, s.duration);
    if (!s.local_endpoint.empty()) {
        auto serialized = encode_endpoint(s.local_endpoint);
        protobuf_wire::encode_message_field(out, 8, serialized);
    }
    if (!s.remote_endpoint.empty()) {
        auto serialized = encode_endpoint(s.remote_endpoint);
        protobuf_wire::encode_message_field(out, 9, serialized);
    }
    for (const auto& ann : s.annotations) {
        auto serialized = encode_annotation(ann);
        protobuf_wire::encode_message_field(out, 10, serialized);
    }
    for (const auto& [key, value] : s.tags) {
        auto entry = encode_string_map_entry(key, value);
        protobuf_wire::encode_message_field(out, 11, entry);
    }
    protobuf_wire::encode_bool_field(out, 12, s.debug);
    protobuf_wire::encode_bool_field(out, 13, s.shared);
    return out;
}

References kcenon::monitoring::zipkin_proto::span::annotations, kcenon::monitoring::zipkin_proto::span::debug, kcenon::monitoring::zipkin_proto::span::duration, kcenon::monitoring::zipkin_proto::endpoint::empty(), encode_annotation(), kcenon::monitoring::protobuf_wire::encode_bool_field(), kcenon::monitoring::protobuf_wire::encode_bytes_field(), encode_endpoint(), kcenon::monitoring::protobuf_wire::encode_enum_field(), kcenon::monitoring::protobuf_wire::encode_fixed64_field(), kcenon::monitoring::protobuf_wire::encode_message_field(), kcenon::monitoring::protobuf_wire::encode_string_field(), encode_string_map_entry(), kcenon::monitoring::protobuf_wire::encode_uint64_field(), kcenon::monitoring::zipkin_proto::span::id, kcenon::monitoring::zipkin_proto::span::kind, kcenon::monitoring::zipkin_proto::span::local_endpoint, kcenon::monitoring::zipkin_proto::span::name, kcenon::monitoring::zipkin_proto::span::parent_id, kcenon::monitoring::zipkin_proto::span::remote_endpoint, kcenon::monitoring::zipkin_proto::span::shared, kcenon::monitoring::zipkin_proto::span::tags, kcenon::monitoring::zipkin_proto::span::timestamp, and kcenon::monitoring::zipkin_proto::span::trace_id.

Referenced by encode_list_of_spans(), and kcenon::monitoring::zipkin_span_data::to_protobuf().

Here is the call graph for this function:

Here is the caller graph for this function:

encode_string_map_entry()

std::vector< std::uint8_t > kcenon::monitoring::zipkin_proto::encode_string_map_entry ( const std::string & key, const std::string & value )

inline

Encode a single entry of a map<string,string> field.

Protobuf encodes map fields as a repeated synthetic message with field 1 = key and field 2 = value.

Definition at line 120 of file zipkin_proto.h.

                                                                                {
    std::vector<std::uint8_t> out;
    protobuf_wire::encode_string_field(out, 1, key);
    protobuf_wire::encode_string_field(out, 2, value);
    return out;
}

References kcenon::monitoring::protobuf_wire::encode_string_field().

Referenced by encode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_kind()

span_kind kcenon::monitoring::zipkin_proto::parse_kind ( const std::string & value )

inline

Convert a textual Zipkin kind (e.g. "CLIENT") to its enum value.

Definition at line 41 of file zipkin_proto.h.

                                                    {
    std::string upper;
    upper.reserve(value.size());
    for (char c : value) {
        if (c >= 'a' && c <= 'z') upper.push_back(static_cast<char>(c - 'a' + 'A'));
        else upper.push_back(c);
    }
    if (upper == "CLIENT") return span_kind::client;
    if (upper == "SERVER") return span_kind::server;
    if (upper == "PRODUCER") return span_kind::producer;
    if (upper == "CONSUMER") return span_kind::consumer;
    return span_kind::unspecified;
}

References client, consumer, producer, server, and unspecified.

Referenced by kcenon::monitoring::encode_zipkin_list_of_spans(), TEST(), and kcenon::monitoring::zipkin_span_data::to_protobuf().

Here is the caller graph for this function: