Classes
struct	batch

struct	key_value

struct	process

struct	span

struct	span_ref

Enumerations
enum class	value_type : std::int32_t { string_type = 0 , bool_type = 1 , int64_type = 2 , float64_type = 3 , binary_type = 4 }

Functions
std::vector< std::uint8_t >	encode_timestamp (std::int64_t seconds, std::int32_t nanos)

std::vector< std::uint8_t >	encode_duration (std::int64_t seconds, std::int32_t nanos)

std::vector< std::uint8_t >	encode_key_value (const key_value &kv)

std::vector< std::uint8_t >	encode_process (const process &p)

std::vector< std::uint8_t >	encode_span_ref (const span_ref &ref)

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

std::vector< std::uint8_t >	encode_batch (const batch &b)

bool	decode_key_value (const std::uint8_t *data, std::size_t size, key_value &out)

bool	decode_process (const std::uint8_t *data, std::size_t size, process &out)

bool	decode_timestamp (const std::uint8_t *data, std::size_t size, std::int64_t &seconds, std::int32_t &nanos)

bool	decode_span_ref (const std::uint8_t *data, std::size_t size, span_ref &out)

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

bool	decode_batch (const std::uint8_t *data, std::size_t size, batch &out)

Enumeration Type Documentation

◆ value_type

enum class kcenon::monitoring::jaeger_proto::value_type : std::int32_t

strong

Enumerator
string_type
bool_type
int64_type
float64_type
binary_type

Definition at line 37 of file jaeger_proto.h.

                      : std::int32_t {
    string_type  = 0,
    bool_type    = 1,
    int64_type   = 2,
    float64_type = 3,
    binary_type  = 4,
};

Function Documentation

◆ decode_batch()

bool kcenon::monitoring::jaeger_proto::decode_batch	(	const std::uint8_t *	data,
		std::size_t	size,
		batch &	out )

inline

Definition at line 407 of file jaeger_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;
                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));
                break;
            }
            case 2: {
                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_process(ptr, len, out.proc)) return false;
                out.has_process = true;
                break;
            }
            default:
                if (!r.skip_field(wt)) return false;
        }
    }
    return true;
}

References decode_process(), decode_span(), kcenon::monitoring::protobuf_wire::decode_tag(), kcenon::monitoring::protobuf_wire::reader::eof(), kcenon::monitoring::jaeger_proto::batch::has_process, kcenon::monitoring::protobuf_wire::length_delimited, kcenon::monitoring::jaeger_proto::batch::proc, kcenon::monitoring::protobuf_wire::reader::read_length_delimited(), kcenon::monitoring::protobuf_wire::reader::skip_field(), and kcenon::monitoring::jaeger_proto::batch::spans.

Referenced by TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decode_key_value()

bool kcenon::monitoring::jaeger_proto::decode_key_value	(	const std::uint8_t *	data,
		std::size_t	size,
		key_value &	out )

inline

Definition at line 194 of file jaeger_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.key)) return false;
                break;
            case 2: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.v_type = static_cast<value_type>(*v);
                break;
            }
            case 3:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_string(out.v_str)) return false;
                break;
            case 4: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.v_bool = (*v != 0);
                break;
            }
            case 5: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.v_int64 = static_cast<std::int64_t>(*v);
                break;
            }
            case 6: {
                if (wt != protobuf_wire::wire_type::fixed64) return false;
                auto v = r.read_fixed64();
                if (!v) return false;
                std::uint64_t bits = *v;
                std::memcpy(&out.v_float64, &bits, sizeof(out.v_float64));
                break;
            }
            case 7:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_bytes(out.v_binary)) return false;
                break;
            default:
                if (!r.skip_field(wt)) return false;
        }
    }
    return true;
}

Referenced by decode_process(), and decode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decode_process()

bool kcenon::monitoring::jaeger_proto::decode_process	(	const std::uint8_t *	data,
		std::size_t	size,
		process &	out )

inline

Definition at line 250 of file jaeger_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;
                const std::uint8_t* ptr; std::size_t len;
                if (!r.read_length_delimited(&ptr, &len)) return false;
                key_value kv;
                if (!decode_key_value(ptr, len, kv)) return false;
                out.tags.push_back(std::move(kv));
                break;
            }
            default:
                if (!r.skip_field(wt)) return false;
        }
    }
    return true;
}

References decode_key_value(), 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(), kcenon::monitoring::jaeger_proto::process::service_name, kcenon::monitoring::protobuf_wire::reader::skip_field(), and kcenon::monitoring::jaeger_proto::process::tags.

Referenced by decode_batch(), and decode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decode_span()

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

inline

Definition at line 328 of file jaeger_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.span_id)) return false;
                break;
            case 3:
                if (wt != protobuf_wire::wire_type::length_delimited) return false;
                if (!r.read_string(out.operation_name)) return false;
                break;
            case 4: {
                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;
                span_ref ref;
                if (!decode_span_ref(ptr, len, ref)) return false;
                out.references.push_back(std::move(ref));
                break;
            }
            case 5: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.flags = static_cast<std::uint32_t>(*v);
                break;
            }
            case 6: {
                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_timestamp(ptr, len,
                                      out.start_time_seconds,
                                      out.start_time_nanos))
                    return false;
                break;
            }
            case 7: {
                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_timestamp(ptr, len,
                                      out.duration_seconds,
                                      out.duration_nanos))
                    return false;
                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;
                key_value kv;
                if (!decode_key_value(ptr, len, kv)) return false;
                out.tags.push_back(std::move(kv));
                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;
                if (!decode_process(ptr, len, out.proc)) return false;
                break;
            }
            default:
                if (!r.skip_field(wt)) return false;
        }
    }
    return true;
}

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ decode_span_ref()

bool kcenon::monitoring::jaeger_proto::decode_span_ref	(	const std::uint8_t *	data,
		std::size_t	size,
		span_ref &	out )

inline

Definition at line 298 of file jaeger_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.span_id)) return false;
                break;
            case 3: {
                if (wt != protobuf_wire::wire_type::varint) return false;
                auto v = r.read_varint();
                if (!v) return false;
                out.ref_type = 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::protobuf_wire::length_delimited, kcenon::monitoring::protobuf_wire::reader::read_bytes(), kcenon::monitoring::protobuf_wire::reader::read_varint(), kcenon::monitoring::jaeger_proto::span_ref::ref_type, kcenon::monitoring::protobuf_wire::reader::skip_field(), kcenon::monitoring::jaeger_proto::span_ref::span_id, kcenon::monitoring::jaeger_proto::span_ref::trace_id, 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_timestamp()

bool kcenon::monitoring::jaeger_proto::decode_timestamp	(	const std::uint8_t *	data,
		std::size_t	size,
		std::int64_t &	seconds,
		std::int32_t &	nanos )

inline

Definition at line 278 of file jaeger_proto.h.

                                                                     {
    protobuf_wire::reader r(data, size);
    seconds = 0; nanos = 0;
    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::varint) {
            if (!r.skip_field(wt)) return false;
            continue;
        }
        auto v = r.read_varint();
        if (!v) return false;
        if (field_number == 1) seconds = static_cast<std::int64_t>(*v);
        else if (field_number == 2) nanos = static_cast<std::int32_t>(*v);
    }
    return true;
}

References kcenon::monitoring::protobuf_wire::decode_tag(), kcenon::monitoring::protobuf_wire::reader::eof(), kcenon::monitoring::protobuf_wire::reader::read_varint(), 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:

◆ encode_batch()

std::vector< std::uint8_t > kcenon::monitoring::jaeger_proto::encode_batch ( const batch & b )

inline

Definition at line 177 of file jaeger_proto.h.

                                                          {
    std::vector<std::uint8_t> out;
    for (const auto& s : b.spans) {
        auto serialized = encode_span(s);
        protobuf_wire::encode_message_field(out, 1, serialized);
    }
    if (b.has_process) {
        auto serialized = encode_process(b.proc);
        protobuf_wire::encode_message_field(out, 2, serialized);
    }
    return out;
}

References kcenon::monitoring::protobuf_wire::encode_message_field(), encode_process(), encode_span(), kcenon::monitoring::jaeger_proto::batch::has_process, kcenon::monitoring::jaeger_proto::batch::proc, and kcenon::monitoring::jaeger_proto::batch::spans.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_duration()

std::vector< std::uint8_t > kcenon::monitoring::jaeger_proto::encode_duration	(	std::int64_t	seconds,
		std::int32_t	nanos )

inline

Definition at line 100 of file jaeger_proto.h.

                                                                   {
    std::vector<std::uint8_t> out;
    protobuf_wire::encode_uint64_field(out, 1, static_cast<std::uint64_t>(seconds));
    protobuf_wire::encode_uint64_field(out, 2, static_cast<std::uint64_t>(nanos));
    return out;
}

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

Referenced by encode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_key_value()

std::vector< std::uint8_t > kcenon::monitoring::jaeger_proto::encode_key_value ( const key_value & kv )

inline

Definition at line 108 of file jaeger_proto.h.

                                                                   {
    std::vector<std::uint8_t> out;
    protobuf_wire::encode_string_field(out, 1, kv.key);
    protobuf_wire::encode_enum_field(out, 2, static_cast<std::int32_t>(kv.v_type));
    protobuf_wire::encode_string_field(out, 3, kv.v_str);
    protobuf_wire::encode_bool_field(out, 4, kv.v_bool);
    if (kv.v_int64 != 0) {
        protobuf_wire::encode_tag(out, 5, protobuf_wire::wire_type::varint);
        protobuf_wire::encode_varint(out, static_cast<std::uint64_t>(kv.v_int64));
    }
    if (kv.v_float64 != 0.0) {
        std::uint64_t bits;
        static_assert(sizeof(bits) == sizeof(kv.v_float64),
                      "double must be 64 bits");
        std::memcpy(&bits, &kv.v_float64, sizeof(bits));
        protobuf_wire::encode_tag(out, 6, protobuf_wire::wire_type::fixed64);
        protobuf_wire::encode_fixed64(out, bits);
    }
    protobuf_wire::encode_bytes_field(out, 7, kv.v_binary);
    return out;
}

Referenced by encode_process(), and encode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_process()

std::vector< std::uint8_t > kcenon::monitoring::jaeger_proto::encode_process ( const process & p )

inline

Definition at line 130 of file jaeger_proto.h.

                                                              {
    std::vector<std::uint8_t> out;
    protobuf_wire::encode_string_field(out, 1, p.service_name);
    for (const auto& tag : p.tags) {
        auto serialized = encode_key_value(tag);
        protobuf_wire::encode_message_field(out, 2, serialized);
    }
    return out;
}

References encode_key_value(), kcenon::monitoring::protobuf_wire::encode_message_field(), kcenon::monitoring::protobuf_wire::encode_string_field(), kcenon::monitoring::jaeger_proto::process::service_name, and kcenon::monitoring::jaeger_proto::process::tags.

Referenced by encode_batch(), and encode_span().

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::jaeger_proto::encode_span ( const span & s )

inline

Definition at line 148 of file jaeger_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.span_id);
    protobuf_wire::encode_string_field(out, 3, s.operation_name);
    for (const auto& ref : s.references) {
        auto serialized = encode_span_ref(ref);
        protobuf_wire::encode_message_field(out, 4, serialized);
    }
    protobuf_wire::encode_uint64_field(out, 5, s.flags);
    if (s.start_time_seconds != 0 || s.start_time_nanos != 0) {
        auto ts = encode_timestamp(s.start_time_seconds, s.start_time_nanos);
        protobuf_wire::encode_message_field(out, 6, ts);
    }
    if (s.duration_seconds != 0 || s.duration_nanos != 0) {
        auto du = encode_duration(s.duration_seconds, s.duration_nanos);
        protobuf_wire::encode_message_field(out, 7, du);
    }
    for (const auto& tag : s.tags) {
        auto serialized = encode_key_value(tag);
        protobuf_wire::encode_message_field(out, 8, serialized);
    }
    if (!s.proc.service_name.empty() || !s.proc.tags.empty()) {
        auto serialized = encode_process(s.proc);
        protobuf_wire::encode_message_field(out, 10, serialized);
    }
    return out;
}

Referenced by encode_batch(), and kcenon::monitoring::jaeger_span_data::to_protobuf().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_span_ref()

std::vector< std::uint8_t > kcenon::monitoring::jaeger_proto::encode_span_ref ( const span_ref & ref )

inline

Definition at line 140 of file jaeger_proto.h.

                                                                  {
    std::vector<std::uint8_t> out;
    protobuf_wire::encode_bytes_field(out, 1, ref.trace_id);
    protobuf_wire::encode_bytes_field(out, 2, ref.span_id);
    protobuf_wire::encode_enum_field(out, 3, ref.ref_type);
    return out;
}

References kcenon::monitoring::protobuf_wire::encode_bytes_field(), kcenon::monitoring::protobuf_wire::encode_enum_field(), kcenon::monitoring::jaeger_proto::span_ref::ref_type, kcenon::monitoring::jaeger_proto::span_ref::span_id, and kcenon::monitoring::jaeger_proto::span_ref::trace_id.

Referenced by encode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ encode_timestamp()

std::vector< std::uint8_t > kcenon::monitoring::jaeger_proto::encode_timestamp	(	std::int64_t	seconds,
		std::int32_t	nanos )

inline

Definition at line 92 of file jaeger_proto.h.

                                                                    {
    std::vector<std::uint8_t> out;
    protobuf_wire::encode_uint64_field(out, 1, static_cast<std::uint64_t>(seconds));
    protobuf_wire::encode_uint64_field(out, 2, static_cast<std::uint64_t>(nanos));
    return out;
}

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

Referenced by encode_span().

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Enumerations

Functions

Enumeration Type Documentation

◆ value_type

Function Documentation

◆ decode_batch()

◆ decode_key_value()

◆ decode_process()

◆ decode_span()

◆ decode_span_ref()

◆ decode_timestamp()

◆ encode_batch()

◆ encode_duration()

◆ encode_key_value()

◆ encode_process()

◆ encode_span()

◆ encode_span_ref()

◆ encode_timestamp()