kcenon::monitoring::otlp_span_converter Class Reference

Converts internal spans to OTLP wire format. More...

#include <otlp_grpc_exporter.h>

Collaboration diagram for kcenon::monitoring::otlp_span_converter:

Static Public Member Functions
static std::vector< uint8_t >	convert_to_otlp (const std::vector< trace_span > &spans, const std::string &service_name, const std::string &service_version, const std::unordered_map< std::string, std::string > &resource_attributes)
	Convert spans to OTLP protobuf format.

Static Private Member Functions
static std::vector< uint8_t >	build_resource_spans (const std::vector< trace_span > &spans, const std::string &service_name, const std::string &service_version, const std::unordered_map< std::string, std::string > &resource_attributes)
static std::vector< uint8_t >	build_resource (const std::string &service_name, const std::string &service_version, const std::unordered_map< std::string, std::string > &extra_attributes)
static std::vector< uint8_t >	build_scope_spans (const std::vector< trace_span > &spans)
static std::vector< uint8_t >	build_scope (const std::string &name, const std::string &version)
static std::vector< uint8_t >	build_span (const trace_span &span)
static std::vector< uint8_t >	build_key_value (const std::string &key, const std::string &value)
static std::vector< uint8_t >	build_any_value_string (const std::string &value)
static void	write_varint (std::vector< uint8_t > &data, uint64_t value)
static void	write_fixed64 (std::vector< uint8_t > &data, uint64_t value)
static std::vector< uint8_t >	hex_to_bytes (const std::string &hex, std::size_t expected_size)

Detailed Description

Converts internal spans to OTLP wire format.

This class handles the conversion of internal trace_span objects to the OTLP protocol buffer format.

Definition at line 106 of file otlp_grpc_exporter.h.

Member Function Documentation

build_any_value_string()

static std::vector< uint8_t > kcenon::monitoring::otlp_span_converter::build_any_value_string ( const std::string & value )

inlinestaticprivate

Definition at line 324 of file otlp_grpc_exporter.h.

                                                                             {
        std::vector<uint8_t> data;
        // Field 1: string_value
        data.push_back(0x0A);
        write_varint(data, value.size());
        data.insert(data.end(), value.begin(), value.end());
        return data;
    }

References write_varint().

Referenced by build_key_value().

Here is the call graph for this function:

Here is the caller graph for this function:

build_key_value()

static std::vector< uint8_t > kcenon::monitoring::otlp_span_converter::build_key_value ( const std::string & key, const std::string & value )

inlinestaticprivate

Definition at line 304 of file otlp_grpc_exporter.h.

                                {
 
        std::vector<uint8_t> data;
 
        // Field 1: key
        data.push_back(0x0A);
        write_varint(data, key.size());
        data.insert(data.end(), key.begin(), key.end());
 
        // Field 2: value (AnyValue)
        auto any_value = build_any_value_string(value);
        data.push_back(0x12);
        write_varint(data, any_value.size());
        data.insert(data.end(), any_value.begin(), any_value.end());
 
        return data;
    }

References build_any_value_string(), and write_varint().

Referenced by build_resource(), and build_span().

Here is the call graph for this function:

Here is the caller graph for this function:

build_resource()

static std::vector< uint8_t > kcenon::monitoring::otlp_span_converter::build_resource ( const std::string & service_name, const std::string & service_version, const std::unordered_map< std::string, std::string > & extra_attributes )

inlinestaticprivate

Definition at line 177 of file otlp_grpc_exporter.h.

                                                                        {
 
        std::vector<uint8_t> data;
 
        // Field 1: attributes (repeated)
        // service.name attribute
        auto attr1 = build_key_value("service.name", service_name);
        data.push_back(0x0A);
        write_varint(data, attr1.size());
        data.insert(data.end(), attr1.begin(), attr1.end());
 
        // service.version attribute
        auto attr2 = build_key_value("service.version", service_version);
        data.push_back(0x0A);
        write_varint(data, attr2.size());
        data.insert(data.end(), attr2.begin(), attr2.end());
 
        // Extra attributes
        for (const auto& [key, value] : extra_attributes) {
            auto attr = build_key_value(key, value);
            data.push_back(0x0A);
            write_varint(data, attr.size());
            data.insert(data.end(), attr.begin(), attr.end());
        }
 
        return data;
    }

References build_key_value(), and write_varint().

Referenced by build_resource_spans().

Here is the call graph for this function:

Here is the caller graph for this function:

build_resource_spans()

static std::vector< uint8_t > kcenon::monitoring::otlp_span_converter::build_resource_spans ( const std::vector< trace_span > & spans, const std::string & service_name, const std::string & service_version, const std::unordered_map< std::string, std::string > & resource_attributes )

inlinestaticprivate

Definition at line 154 of file otlp_grpc_exporter.h.

                                                                           {
 
        std::vector<uint8_t> data;
 
        // Field 1: resource
        auto resource_data = build_resource(service_name, service_version, resource_attributes);
        data.push_back(0x0A);  // Field 1, length-delimited
        write_varint(data, resource_data.size());
        data.insert(data.end(), resource_data.begin(), resource_data.end());
 
        // Field 2: scope_spans
        auto scope_spans_data = build_scope_spans(spans);
        data.push_back(0x12);  // Field 2, length-delimited
        write_varint(data, scope_spans_data.size());
        data.insert(data.end(), scope_spans_data.begin(), scope_spans_data.end());
 
        return data;
    }

References build_resource(), build_scope_spans(), and write_varint().

Referenced by convert_to_otlp().

Here is the call graph for this function:

Here is the caller graph for this function:

build_scope()

static std::vector< uint8_t > kcenon::monitoring::otlp_span_converter::build_scope ( const std::string & name, const std::string & version )

inlinestaticprivate

Definition at line 230 of file otlp_grpc_exporter.h.

                                  {
 
        std::vector<uint8_t> data;
 
        // Field 1: name
        data.push_back(0x0A);
        write_varint(data, name.size());
        data.insert(data.end(), name.begin(), name.end());
 
        // Field 2: version
        data.push_back(0x12);
        write_varint(data, version.size());
        data.insert(data.end(), version.begin(), version.end());
 
        return data;
    }

References write_varint().

Referenced by build_scope_spans().

Here is the call graph for this function:

Here is the caller graph for this function:

build_scope_spans()

static std::vector< uint8_t > kcenon::monitoring::otlp_span_converter::build_scope_spans ( const std::vector< trace_span > & spans )

inlinestaticprivate

Definition at line 208 of file otlp_grpc_exporter.h.

                                            {
 
        std::vector<uint8_t> data;
 
        // Field 1: scope (InstrumentationScope)
        auto scope_data = build_scope("monitoring_system", "2.0.0");
        data.push_back(0x0A);
        write_varint(data, scope_data.size());
        data.insert(data.end(), scope_data.begin(), scope_data.end());
 
        // Field 2: spans (repeated)
        for (const auto& span : spans) {
            auto span_data = build_span(span);
            data.push_back(0x12);
            write_varint(data, span_data.size());
            data.insert(data.end(), span_data.begin(), span_data.end());
        }
 
        return data;
    }

References build_scope(), build_span(), and write_varint().

Referenced by build_resource_spans().

Here is the call graph for this function:

Here is the caller graph for this function:

build_span()

static std::vector< uint8_t > kcenon::monitoring::otlp_span_converter::build_span ( const trace_span & span )

inlinestaticprivate

Definition at line 249 of file otlp_grpc_exporter.h.

                                                                 {
        std::vector<uint8_t> data;
 
        // Field 1: trace_id (16 bytes)
        auto trace_id_bytes = hex_to_bytes(span.trace_id, 16);
        data.push_back(0x0A);
        write_varint(data, trace_id_bytes.size());
        data.insert(data.end(), trace_id_bytes.begin(), trace_id_bytes.end());
 
        // Field 2: span_id (8 bytes)
        auto span_id_bytes = hex_to_bytes(span.span_id, 8);
        data.push_back(0x12);
        write_varint(data, span_id_bytes.size());
        data.insert(data.end(), span_id_bytes.begin(), span_id_bytes.end());
 
        // Field 4: parent_span_id (8 bytes, optional)
        if (!span.parent_span_id.empty()) {
            auto parent_id_bytes = hex_to_bytes(span.parent_span_id, 8);
            data.push_back(0x22);
            write_varint(data, parent_id_bytes.size());
            data.insert(data.end(), parent_id_bytes.begin(), parent_id_bytes.end());
        }
 
        // Field 5: name
        data.push_back(0x2A);
        write_varint(data, span.operation_name.size());
        data.insert(data.end(), span.operation_name.begin(), span.operation_name.end());
 
        // Field 6: kind (SPAN_KIND_INTERNAL = 1)
        data.push_back(0x30);
        data.push_back(0x01);
 
        // Field 7: start_time_unix_nano (fixed64)
        auto start_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
            span.start_time.time_since_epoch()).count();
        data.push_back(0x39);  // Field 7, wire type 1 (64-bit)
        write_fixed64(data, static_cast<uint64_t>(start_ns));
 
        // Field 8: end_time_unix_nano (fixed64)
        auto end_ns = std::chrono::duration_cast<std::chrono::nanoseconds>(
            span.end_time.time_since_epoch()).count();
        data.push_back(0x41);  // Field 8, wire type 1 (64-bit)
        write_fixed64(data, static_cast<uint64_t>(end_ns));
 
        // Field 9: attributes (repeated)
        for (const auto& [key, value] : span.tags) {
            auto attr = build_key_value(key, value);
            data.push_back(0x4A);
            write_varint(data, attr.size());
            data.insert(data.end(), attr.begin(), attr.end());
        }
 
        return data;
    }

References build_key_value(), kcenon::monitoring::trace_span::end_time, hex_to_bytes(), kcenon::monitoring::trace_span::operation_name, kcenon::monitoring::trace_span::parent_span_id, kcenon::monitoring::trace_span::span_id, kcenon::monitoring::trace_span::start_time, kcenon::monitoring::trace_span::tags, kcenon::monitoring::trace_span::trace_id, write_fixed64(), and write_varint().

Referenced by build_scope_spans().

Here is the call graph for this function:

Here is the caller graph for this function:

convert_to_otlp()

static std::vector< uint8_t > kcenon::monitoring::otlp_span_converter::convert_to_otlp ( const std::vector< trace_span > & spans, const std::string & service_name, const std::string & service_version, const std::unordered_map< std::string, std::string > & resource_attributes )

inlinestatic

Convert spans to OTLP protobuf format.

Parameters

spans	Vector of spans to convert
service_name	Service name for resource
service_version	Service version
resource_attributes	Additional resource attributes

Returns

Serialized OTLP ExportTraceServiceRequest

Definition at line 116 of file otlp_grpc_exporter.h.

                                                                           {
 
        // OTLP ExportTraceServiceRequest structure:
        // - resource_spans (repeated)
        //   - resource
        //     - attributes
        //   - scope_spans (repeated)
        //     - scope
        //     - spans (repeated)
 
        std::vector<uint8_t> payload;
 
        // Build minimal OTLP-compatible protobuf structure
        // Note: Full implementation would use generated protobuf code
 
        // For now, we serialize to a simplified format that OpenTelemetry
        // Collector can process. Production use should integrate actual
        // OTLP proto definitions.
 
        // Write field 1 (resource_spans) - length-delimited
        auto resource_spans_data = build_resource_spans(
            spans, service_name, service_version, resource_attributes);
 
        // Protobuf wire format: (field_number << 3) | wire_type
        // Field 1, wire type 2 (length-delimited) = 0x0A
        payload.push_back(0x0A);
        write_varint(payload, resource_spans_data.size());
        payload.insert(payload.end(),
            resource_spans_data.begin(), resource_spans_data.end());
 
        return payload;
    }

References build_resource_spans(), and write_varint().

Referenced by kcenon::monitoring::otlp_grpc_exporter::export_spans(), TEST_F(), and TEST_F().

Here is the call graph for this function:

Here is the caller graph for this function:

hex_to_bytes()

static std::vector< uint8_t > kcenon::monitoring::otlp_span_converter::hex_to_bytes ( const std::string & hex, std::size_t expected_size )

inlinestaticprivate

Definition at line 348 of file otlp_grpc_exporter.h.

                                                                                          {
        std::vector<uint8_t> bytes;
        bytes.reserve(expected_size);
 
        for (std::size_t i = 0; i + 1 < hex.size(); i += 2) {
            auto byte_str = hex.substr(i, 2);
            try {
                bytes.push_back(static_cast<uint8_t>(std::stoul(byte_str, nullptr, 16)));
            } catch (...) {
                bytes.push_back(0);
            }
        }
 
        // Pad or truncate to expected size
        while (bytes.size() < expected_size) {
            bytes.insert(bytes.begin(), 0);
        }
        if (bytes.size() > expected_size) {
            bytes.resize(expected_size);
        }
 
        return bytes;
    }

Referenced by build_span().

Here is the caller graph for this function:

write_fixed64()

static void kcenon::monitoring::otlp_span_converter::write_fixed64 ( std::vector< uint8_t > & data, uint64_t value )

inlinestaticprivate

Definition at line 341 of file otlp_grpc_exporter.h.

                                                                        {
        for (int i = 0; i < 8; ++i) {
            data.push_back(static_cast<uint8_t>(value & 0xFF));
            value >>= 8;
        }
    }

Referenced by build_span().

Here is the caller graph for this function:

write_varint()

static void kcenon::monitoring::otlp_span_converter::write_varint ( std::vector< uint8_t > & data, uint64_t value )

inlinestaticprivate

Definition at line 333 of file otlp_grpc_exporter.h.

                                                                       {
        while (value >= 0x80) {
            data.push_back(static_cast<uint8_t>(value | 0x80));
            value >>= 7;
        }
        data.push_back(static_cast<uint8_t>(value));
    }

Referenced by build_any_value_string(), build_key_value(), build_resource(), build_resource_spans(), build_scope(), build_scope_spans(), build_span(), and convert_to_otlp().

Here is the caller graph for this function:

---

The documentation for this class was generated from the following file:

• include/kcenon/monitoring/exporters/otlp_grpc_exporter.h