test_trace_exporters.cpp File Reference

#include <gtest/gtest.h>
#include <kcenon/monitoring/exporters/trace_exporters.h>
#include <kcenon/monitoring/exporters/opentelemetry_adapter.h>
#include <thread>
#include <chrono>
#include <kcenon/monitoring/exporters/internal/jaeger_proto.h>
#include <kcenon/monitoring/exporters/internal/zipkin_proto.h>
#include <kcenon/monitoring/exporters/otlp_grpc_exporter.h>

Include dependency graph for test_trace_exporters.cpp:

Go to the source code of this file.

Classes
class	TraceExportersTest
class	OtlpGrpcExporterTest

Functions
	TEST_F (TraceExportersTest, TraceExportConfigValidation)
	TEST_F (TraceExportersTest, JaegerSpanConversion)
	TEST_F (TraceExportersTest, JaegerExporterBasicFunctionality)
	TEST_F (TraceExportersTest, ZipkinSpanConversion)
	TEST_F (TraceExportersTest, ZipkinExporterBasicFunctionality)
	TEST_F (TraceExportersTest, OtlpExporterBasicFunctionality)
	TEST_F (TraceExportersTest, TraceExporterFactory)
	TEST_F (TraceExportersTest, SupportedFormatsQuery)
	TEST_F (TraceExportersTest, HelperFunctions)
	TEST_F (TraceExportersTest, InvalidFormatHandling)
	TEST_F (TraceExportersTest, EmptySpansHandling)
	TEST_F (TraceExportersTest, LargeSpanBatch)
	TEST (ProtobufWireTest, VarintRoundTrip)
	TEST (ProtobufWireTest, HexBytesRoundTrip)
	TEST_F (TraceExportersTest, JaegerSpanProtobufRoundTrip)
	TEST_F (TraceExportersTest, JaegerSpanProtobufParentReference)
	TEST_F (TraceExportersTest, JaegerBatchProtobufRoundTrip)
	TEST_F (TraceExportersTest, ZipkinSpanProtobufRoundTrip)
	TEST_F (TraceExportersTest, ZipkinSpanProtobufParent)
	TEST_F (TraceExportersTest, ZipkinListOfSpansRoundTrip)
	TEST (ZipkinProtoTest, SpanKindParsing)
	TEST_F (OtlpGrpcExporterTest, ConfigValidation)
	TEST_F (OtlpGrpcExporterTest, SpanConverterBasic)
	TEST_F (OtlpGrpcExporterTest, SpanConverterEmptySpans)
	TEST_F (OtlpGrpcExporterTest, ExporterWithStubTransport)
	TEST_F (OtlpGrpcExporterTest, ExporterFailedConnection)
	TEST_F (OtlpGrpcExporterTest, ExporterRetryBehavior)
	TEST_F (OtlpGrpcExporterTest, ExporterDetailedStats)
	TEST_F (OtlpGrpcExporterTest, FactoryFunctions)
	TEST_F (OtlpGrpcExporterTest, ExportEmptySpans)

Function Documentation

TEST() [1/3]

TEST	(	ProtobufWireTest	,
		HexBytesRoundTrip	)

Definition at line 400 of file test_trace_exporters.cpp.

                                          {
    using namespace kcenon::monitoring::protobuf_wire;
    const std::string hex = "0123456789abcdef";
    auto bytes = hex_to_bytes(hex);
    EXPECT_EQ(bytes.size(), 8u);
    EXPECT_EQ(bytes_to_hex(bytes), hex);
 
    // Invalid hex yields empty
    EXPECT_TRUE(hex_to_bytes("xyz").empty());
 
    // Left-padding to 16 bytes
    auto padded = left_pad(bytes, 16);
    EXPECT_EQ(padded.size(), 16u);
    for (std::size_t i = 0; i < 8; ++i) EXPECT_EQ(padded[i], 0u);
    for (std::size_t i = 0; i < 8; ++i) EXPECT_EQ(padded[8 + i], bytes[i]);
}

TEST() [2/3]

TEST	(	ProtobufWireTest	,
		VarintRoundTrip	)

Definition at line 383 of file test_trace_exporters.cpp.

                                        {
    using namespace kcenon::monitoring::protobuf_wire;
    const std::uint64_t values[] = {
        0, 1, 127, 128, 255, 16383, 16384,
        1000000000ULL, (std::uint64_t{1} << 63)
    };
    for (std::uint64_t v : values) {
        std::vector<std::uint8_t> buf;
        encode_varint(buf, v);
        reader r(buf.data(), buf.size());
        auto got = r.read_varint();
        ASSERT_TRUE(got.has_value()) << "failed for value " << v;
        EXPECT_EQ(*got, v);
        EXPECT_TRUE(r.eof());
    }
}

References kcenon::monitoring::protobuf_wire::reader::eof(), and kcenon::monitoring::protobuf_wire::reader::read_varint().

Here is the call graph for this function:

TEST() [3/3]

TEST	(	ZipkinProtoTest	,
		SpanKindParsing	)

Definition at line 571 of file test_trace_exporters.cpp.

                                       {
    using kcenon::monitoring::zipkin_proto::parse_kind;
    using kcenon::monitoring::zipkin_proto::span_kind;
    EXPECT_EQ(parse_kind("CLIENT"), span_kind::client);
    EXPECT_EQ(parse_kind("server"), span_kind::server);
    EXPECT_EQ(parse_kind("Producer"), span_kind::producer);
    EXPECT_EQ(parse_kind("CONSUMER"), span_kind::consumer);
    EXPECT_EQ(parse_kind(""), span_kind::unspecified);
    EXPECT_EQ(parse_kind("INTERNAL"), span_kind::unspecified);
}

References kcenon::monitoring::zipkin_proto::parse_kind().

Here is the call graph for this function:

TEST_F() [1/27]

TEST_F	(	OtlpGrpcExporterTest	,
		ConfigValidation	)

Definition at line 595 of file test_trace_exporters.cpp.

                                               {
    // Valid configuration
    otlp_grpc_config valid_config;
    valid_config.endpoint = "localhost:4317";
    valid_config.timeout = std::chrono::milliseconds(5000);
    valid_config.max_batch_size = 512;
 
    auto validation = valid_config.validate();
    EXPECT_TRUE(validation.is_ok());
 
    // Invalid endpoint (empty)
    otlp_grpc_config invalid_endpoint;
    invalid_endpoint.endpoint = "";
    auto endpoint_validation = invalid_endpoint.validate();
    EXPECT_TRUE(endpoint_validation.is_err());
 
    // Invalid timeout (zero)
    otlp_grpc_config invalid_timeout;
    invalid_timeout.endpoint = "localhost:4317";
    invalid_timeout.timeout = std::chrono::milliseconds(0);
    auto timeout_validation = invalid_timeout.validate();
    EXPECT_TRUE(timeout_validation.is_err());
 
    // Invalid batch size (zero)
    otlp_grpc_config invalid_batch;
    invalid_batch.endpoint = "localhost:4317";
    invalid_batch.max_batch_size = 0;
    auto batch_validation = invalid_batch.validate();
    EXPECT_TRUE(batch_validation.is_err());
}

References kcenon::monitoring::otlp_grpc_config::endpoint, kcenon::monitoring::otlp_grpc_config::max_batch_size, kcenon::monitoring::otlp_grpc_config::timeout, and kcenon::monitoring::otlp_grpc_config::validate().

Here is the call graph for this function:

TEST_F() [2/27]

TEST_F	(	OtlpGrpcExporterTest	,
		ExportEmptySpans	)

Definition at line 805 of file test_trace_exporters.cpp.

                                               {
    otlp_grpc_config config;
    config.endpoint = "localhost:4317";
 
    auto stub_transport = create_stub_grpc_transport();
    otlp_grpc_exporter exporter(config, std::move(stub_transport));
 
    auto start_result = exporter.start();
    EXPECT_TRUE(start_result.is_ok());
 
    // Export empty vector should succeed without sending
    std::vector<trace_span> empty_spans;
    auto export_result = exporter.export_spans(empty_spans);
    EXPECT_TRUE(export_result.is_ok());
 
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_spans"], 0u);
}

References kcenon::monitoring::create_stub_grpc_transport(), kcenon::monitoring::otlp_grpc_config::endpoint, kcenon::monitoring::otlp_grpc_exporter::export_spans(), kcenon::monitoring::otlp_grpc_exporter::get_stats(), and kcenon::monitoring::otlp_grpc_exporter::start().

Here is the call graph for this function:

TEST_F() [3/27]

TEST_F	(	OtlpGrpcExporterTest	,
		ExporterDetailedStats	)

Definition at line 749 of file test_trace_exporters.cpp.

                                                    {
    otlp_grpc_config config;
    config.endpoint = "localhost:4317";
 
    auto stub_transport = create_stub_grpc_transport();
    // Set response handler to simulate realistic export time
    stub_transport->set_response_handler([](const grpc_request&) {
        // Simulate a small delay to ensure measurable export time
        std::this_thread::sleep_for(std::chrono::microseconds(100));
        grpc_response response;
        response.status_code = 0;  // OK
        response.status_message = "OK";
        return response;
    });
    otlp_grpc_exporter exporter(config, std::move(stub_transport));
 
    auto start_result = exporter.start();
    EXPECT_TRUE(start_result.is_ok());
 
    // Export multiple batches
    for (int i = 0; i < 3; ++i) {
        auto result = exporter.export_spans(test_spans_);
        EXPECT_TRUE(result.is_ok());
    }
 
    auto detailed_stats = exporter.get_detailed_stats();
    EXPECT_EQ(detailed_stats.spans_exported, test_spans_.size() * 3);
    EXPECT_EQ(detailed_stats.spans_dropped, 0u);
    EXPECT_EQ(detailed_stats.export_failures, 0u);
    EXPECT_GT(detailed_stats.total_export_time.count(), 0);
}

References kcenon::monitoring::create_stub_grpc_transport(), kcenon::monitoring::otlp_grpc_config::endpoint, kcenon::monitoring::otlp_grpc_exporter::export_spans(), kcenon::monitoring::otlp_grpc_exporter::get_detailed_stats(), kcenon::monitoring::otlp_grpc_exporter::start(), kcenon::monitoring::grpc_response::status_code, and kcenon::monitoring::grpc_response::status_message.

Here is the call graph for this function:

TEST_F() [4/27]

TEST_F	(	OtlpGrpcExporterTest	,
		ExporterFailedConnection	)

Definition at line 693 of file test_trace_exporters.cpp.

                                                       {
    otlp_grpc_config config;
    config.endpoint = "localhost:4317";
 
    // Create stub transport that simulates failure
    auto stub_transport = create_stub_grpc_transport();
    stub_transport->set_simulate_success(false);
 
    otlp_grpc_exporter exporter(config, std::move(stub_transport));
 
    // Start should fail due to connection failure
    auto start_result = exporter.start();
    EXPECT_TRUE(start_result.is_err());
}

References kcenon::monitoring::create_stub_grpc_transport(), kcenon::monitoring::otlp_grpc_config::endpoint, and kcenon::monitoring::otlp_grpc_exporter::start().

Here is the call graph for this function:

TEST_F() [5/27]

TEST_F	(	OtlpGrpcExporterTest	,
		ExporterRetryBehavior	)

Definition at line 708 of file test_trace_exporters.cpp.

                                                    {
    otlp_grpc_config config;
    config.endpoint = "localhost:4317";
    config.max_retry_attempts = 3;
    config.initial_backoff = std::chrono::milliseconds(10);
 
    // Track call count
    int call_count = 0;
 
    auto stub_transport = create_stub_grpc_transport();
    stub_transport->set_response_handler([&call_count](const grpc_request&) {
        call_count++;
        grpc_response response;
        if (call_count < 3) {
            // Simulate UNAVAILABLE error (retryable)
            response.status_code = 14;
            response.status_message = "Service unavailable";
        } else {
            // Success on third attempt
            response.status_code = 0;
            response.status_message = "OK";
        }
        return response;
    });
 
    otlp_grpc_exporter exporter(config, std::move(stub_transport));
 
    auto start_result = exporter.start();
    EXPECT_TRUE(start_result.is_ok());
 
    auto export_result = exporter.export_spans(test_spans_);
    EXPECT_TRUE(export_result.is_ok());
 
    // Should have retried twice before success
    EXPECT_EQ(call_count, 3);
 
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["retries"], 2u);
    EXPECT_EQ(stats["exported_spans"], test_spans_.size());
}

References kcenon::monitoring::create_stub_grpc_transport(), kcenon::monitoring::otlp_grpc_config::endpoint, kcenon::monitoring::otlp_grpc_exporter::export_spans(), kcenon::monitoring::otlp_grpc_exporter::get_stats(), kcenon::monitoring::otlp_grpc_config::initial_backoff, kcenon::monitoring::otlp_grpc_config::max_retry_attempts, kcenon::monitoring::otlp_grpc_exporter::start(), kcenon::monitoring::grpc_response::status_code, and kcenon::monitoring::grpc_response::status_message.

Here is the call graph for this function:

TEST_F() [6/27]

TEST_F	(	OtlpGrpcExporterTest	,
		ExporterWithStubTransport	)

Definition at line 655 of file test_trace_exporters.cpp.

                                                        {
    otlp_grpc_config config;
    config.endpoint = "localhost:4317";
    config.service_name = "test_service";
    config.service_version = "1.0.0";
 
    // Create exporter with stub transport for testing
    auto stub_transport = create_stub_grpc_transport();
    auto* stub_ptr = stub_transport.get();
 
    otlp_grpc_exporter exporter(config, std::move(stub_transport));
 
    // Start exporter (connects to stub)
    auto start_result = exporter.start();
    EXPECT_TRUE(start_result.is_ok());
    EXPECT_TRUE(exporter.is_running());
 
    // Export spans
    auto export_result = exporter.export_spans(test_spans_);
    EXPECT_TRUE(export_result.is_ok());
 
    // Check stats
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_spans"], test_spans_.size());
    EXPECT_EQ(stats["dropped_spans"], 0u);
    EXPECT_EQ(stats["failed_exports"], 0u);
 
    // Check transport statistics
    auto transport_stats = stub_ptr->get_statistics();
    EXPECT_EQ(transport_stats.requests_sent, 1u);
    EXPECT_GT(transport_stats.bytes_sent, 0u);
 
    // Shutdown
    auto shutdown_result = exporter.shutdown();
    EXPECT_TRUE(shutdown_result.is_ok());
    EXPECT_FALSE(exporter.is_running());
}

References kcenon::monitoring::create_stub_grpc_transport(), kcenon::monitoring::otlp_grpc_config::endpoint, kcenon::monitoring::otlp_grpc_exporter::export_spans(), kcenon::monitoring::otlp_grpc_exporter::get_stats(), kcenon::monitoring::otlp_grpc_exporter::is_running(), kcenon::monitoring::otlp_grpc_config::service_name, kcenon::monitoring::otlp_grpc_config::service_version, kcenon::monitoring::otlp_grpc_exporter::shutdown(), and kcenon::monitoring::otlp_grpc_exporter::start().

Here is the call graph for this function:

TEST_F() [7/27]

TEST_F	(	OtlpGrpcExporterTest	,
		FactoryFunctions	)

Definition at line 781 of file test_trace_exporters.cpp.

                                               {
    // Test default factory
    auto exporter1 = create_otlp_grpc_exporter();
    EXPECT_TRUE(exporter1 != nullptr);
    EXPECT_EQ(exporter1->config().endpoint, "localhost:4317");
 
    // Test factory with endpoint
    auto exporter2 = create_otlp_grpc_exporter("collector:4317");
    EXPECT_TRUE(exporter2 != nullptr);
    EXPECT_EQ(exporter2->config().endpoint, "collector:4317");
 
    // Test factory with config
    otlp_grpc_config config;
    config.endpoint = "otlp.example.com:443";
    config.use_tls = true;
    config.service_name = "my_service";
 
    auto exporter3 = create_otlp_grpc_exporter(config);
    EXPECT_TRUE(exporter3 != nullptr);
    EXPECT_EQ(exporter3->config().endpoint, "otlp.example.com:443");
    EXPECT_TRUE(exporter3->config().use_tls);
    EXPECT_EQ(exporter3->config().service_name, "my_service");
}

References kcenon::monitoring::create_otlp_grpc_exporter(), kcenon::monitoring::otlp_grpc_config::endpoint, kcenon::monitoring::otlp_grpc_config::service_name, and kcenon::monitoring::otlp_grpc_config::use_tls.

Here is the call graph for this function:

TEST_F() [8/27]

TEST_F	(	OtlpGrpcExporterTest	,
		SpanConverterBasic	)

Definition at line 626 of file test_trace_exporters.cpp.

                                                 {
    // Test span conversion to OTLP format
    auto payload = otlp_span_converter::convert_to_otlp(
        test_spans_,
        "test_service",
        "1.0.0",
        {{"environment", "test"}});
 
    // Verify payload is non-empty
    EXPECT_GT(payload.size(), 0u);
 
    // Verify protobuf wire format structure
    // First byte should be 0x0A (field 1, length-delimited)
    EXPECT_EQ(payload[0], 0x0A);
}

References kcenon::monitoring::otlp_span_converter::convert_to_otlp().

Here is the call graph for this function:

TEST_F() [9/27]

TEST_F	(	OtlpGrpcExporterTest	,
		SpanConverterEmptySpans	)

Definition at line 642 of file test_trace_exporters.cpp.

                                                      {
    std::vector<trace_span> empty_spans;
 
    auto payload = otlp_span_converter::convert_to_otlp(
        empty_spans,
        "test_service",
        "1.0.0",
        {});
 
    // Even with no spans, should have resource data
    EXPECT_GT(payload.size(), 0u);
}

References kcenon::monitoring::otlp_span_converter::convert_to_otlp().

Here is the call graph for this function:

TEST_F() [10/27]

TEST_F	(	TraceExportersTest	,
		EmptySpansHandling	)

Definition at line 334 of file test_trace_exporters.cpp.

                                               {
    std::vector<trace_span> empty_spans;
 
    trace_export_config config;
    config.endpoint = "http://test:1234";
    config.format = trace_export_format::jaeger_grpc;
 
    jaeger_exporter exporter(config);
    auto result = exporter.export_spans(empty_spans);
    // Empty spans may succeed (nothing to send) or fail (stub transport)
    // Either way, no spans were exported
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_spans"], 0);
}

References kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::jaeger_exporter::export_spans(), kcenon::monitoring::trace_export_config::format, and kcenon::monitoring::jaeger_exporter::get_stats().

Here is the call graph for this function:

TEST_F() [11/27]

TEST_F	(	TraceExportersTest	,
		HelperFunctions	)

Definition at line 288 of file test_trace_exporters.cpp.

                                            {
    // Test Jaeger helper
    auto jaeger_exporter = create_jaeger_exporter("http://jaeger:14268", 
                                                 trace_export_format::jaeger_thrift);
    EXPECT_TRUE(jaeger_exporter);
    
    // Test Zipkin helper
    auto zipkin_exporter = create_zipkin_exporter("http://zipkin:9411", 
                                                 trace_export_format::zipkin_protobuf);
    EXPECT_TRUE(zipkin_exporter);
    
    // Test OTLP helper
    auto otlp_exporter = create_otlp_exporter("http://otlp:4317", otel_resource_, 
                                             trace_export_format::otlp_http_json);
    EXPECT_TRUE(otlp_exporter);
}

References kcenon::monitoring::create_jaeger_exporter(), kcenon::monitoring::create_otlp_exporter(), and kcenon::monitoring::create_zipkin_exporter().

Here is the call graph for this function:

TEST_F() [12/27]

TEST_F	(	TraceExportersTest	,
		InvalidFormatHandling	)

Definition at line 305 of file test_trace_exporters.cpp.

                                                  {
    trace_export_config invalid_jaeger_config;
    invalid_jaeger_config.endpoint = "http://jaeger:14268";
    invalid_jaeger_config.format = trace_export_format::zipkin_json; // Wrong format
 
    jaeger_exporter jaeger_exp(invalid_jaeger_config);
    auto jaeger_result = jaeger_exp.export_spans(test_spans_);
    EXPECT_TRUE(jaeger_result.is_err());
    EXPECT_EQ(jaeger_result.error().code, static_cast<int>(monitoring_error_code::invalid_configuration));
 
    trace_export_config invalid_zipkin_config;
    invalid_zipkin_config.endpoint = "http://zipkin:9411";
    invalid_zipkin_config.format = trace_export_format::jaeger_grpc; // Wrong format
 
    zipkin_exporter zipkin_exp(invalid_zipkin_config);
    auto zipkin_result = zipkin_exp.export_spans(test_spans_);
    EXPECT_TRUE(zipkin_result.is_err());
    EXPECT_EQ(zipkin_result.error().code, static_cast<int>(monitoring_error_code::invalid_configuration));
 
    trace_export_config invalid_otlp_config;
    invalid_otlp_config.endpoint = "http://otlp:4317";
    invalid_otlp_config.format = trace_export_format::jaeger_thrift; // Wrong format
 
    otlp_exporter otlp_exp(invalid_otlp_config, otel_resource_);
    auto otlp_result = otlp_exp.export_spans(test_spans_);
    EXPECT_TRUE(otlp_result.is_err());
    EXPECT_EQ(otlp_result.error().code, static_cast<int>(monitoring_error_code::invalid_configuration));
}

References kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::jaeger_exporter::export_spans(), kcenon::monitoring::otlp_exporter::export_spans(), kcenon::monitoring::zipkin_exporter::export_spans(), and kcenon::monitoring::trace_export_config::format.

Here is the call graph for this function:

TEST_F() [13/27]

TEST_F	(	TraceExportersTest	,
		JaegerBatchProtobufRoundTrip	)

Definition at line 479 of file test_trace_exporters.cpp.

                                                         {
    trace_export_config config;
    config.endpoint = "http://jaeger:14268";
    config.format = trace_export_format::jaeger_grpc;
    config.service_name = "batch_service";
 
    jaeger_exporter exporter(config);
    std::vector<jaeger_span_data> jaeger_spans;
    for (const auto& s : test_spans_) {
        jaeger_spans.push_back(exporter.convert_span(s));
    }
    auto wire = encode_jaeger_batch(jaeger_spans, "batch_service");
    ASSERT_FALSE(wire.empty());
 
    kcenon::monitoring::jaeger_proto::batch decoded;
    ASSERT_TRUE(kcenon::monitoring::jaeger_proto::decode_batch(
        wire.data(), wire.size(), decoded));
    EXPECT_EQ(decoded.spans.size(), test_spans_.size());
    EXPECT_TRUE(decoded.has_process);
    EXPECT_EQ(decoded.proc.service_name, "batch_service");
}

References kcenon::monitoring::jaeger_exporter::convert_span(), kcenon::monitoring::jaeger_proto::decode_batch(), kcenon::monitoring::encode_jaeger_batch(), kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::trace_export_config::format, kcenon::monitoring::jaeger_proto::batch::has_process, kcenon::monitoring::jaeger_proto::batch::proc, kcenon::monitoring::jaeger_proto::process::service_name, kcenon::monitoring::trace_export_config::service_name, and kcenon::monitoring::jaeger_proto::batch::spans.

Here is the call graph for this function:

TEST_F() [14/27]

TEST_F	(	TraceExportersTest	,
		JaegerExporterBasicFunctionality	)

Definition at line 145 of file test_trace_exporters.cpp.

                                                             {
    trace_export_config config;
    config.endpoint = "http://jaeger:14268/api/traces";
    config.format = trace_export_format::jaeger_thrift;
 
    jaeger_exporter exporter(config);
 
    // Export spans — stub transport returns error (no real HTTP client)
    auto export_result = exporter.export_spans(test_spans_);
    EXPECT_TRUE(export_result.is_err());
 
    // Check statistics — export failed so failed_exports should increment
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["failed_exports"], 1);
 
    // Test flush and shutdown (should still work)
    auto flush_result = exporter.flush();
    EXPECT_TRUE(flush_result.is_ok());
 
    auto shutdown_result = exporter.shutdown();
    EXPECT_TRUE(shutdown_result.is_ok());
}

References kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::jaeger_exporter::export_spans(), kcenon::monitoring::jaeger_exporter::flush(), kcenon::monitoring::trace_export_config::format, kcenon::monitoring::jaeger_exporter::get_stats(), and kcenon::monitoring::jaeger_exporter::shutdown().

Here is the call graph for this function:

TEST_F() [15/27]

TEST_F	(	TraceExportersTest	,
		JaegerSpanConversion	)

Definition at line 105 of file test_trace_exporters.cpp.

                                                 {
    trace_export_config config;
    config.endpoint = "http://jaeger:14268/api/traces";
    config.format = trace_export_format::jaeger_thrift;
    config.service_name = "test_service";
    
    jaeger_exporter exporter(config);
    
    const auto& span = test_spans_[0];
    auto jaeger_span = exporter.convert_span(span);
    
    EXPECT_EQ(jaeger_span.trace_id, span.trace_id);
    EXPECT_EQ(jaeger_span.span_id, span.span_id);
    EXPECT_EQ(jaeger_span.operation_name, span.operation_name);
    EXPECT_EQ(jaeger_span.service_name, "test_service"); // Override from config
    
    // Check tags conversion
    bool found_http_method = false;
    bool found_http_url = false;
    for (const auto& [key, value] : jaeger_span.tags) {
        if (key == "http.method" && value == "GET") {
            found_http_method = true;
        }
        if (key == "http.url" && value == "/api/users") {
            found_http_url = true;
        }
    }
    EXPECT_TRUE(found_http_method);
    EXPECT_TRUE(found_http_url);
    
    // Check process tags
    bool found_service_name = false;
    for (const auto& [key, value] : jaeger_span.process_tags) {
        if (key == "service.name" && value == "test_service") {
            found_service_name = true;
        }
    }
    EXPECT_TRUE(found_service_name);
}

References kcenon::monitoring::jaeger_exporter::convert_span(), kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::trace_export_config::format, and kcenon::monitoring::trace_export_config::service_name.

Here is the call graph for this function:

TEST_F() [16/27]

TEST_F	(	TraceExportersTest	,
		JaegerSpanProtobufParentReference	)

Definition at line 460 of file test_trace_exporters.cpp.

                                                              {
    trace_export_config config;
    config.endpoint = "http://jaeger:14268";
    config.format = trace_export_format::jaeger_grpc;
 
    jaeger_exporter exporter(config);
    // Second test span has parent_span_id set.
    auto jaeger_span = exporter.convert_span(test_spans_[1]);
    auto wire = jaeger_span.to_protobuf();
 
    kcenon::monitoring::jaeger_proto::span decoded;
    ASSERT_TRUE(kcenon::monitoring::jaeger_proto::decode_span(
        wire.data(), wire.size(), decoded));
 
    ASSERT_EQ(decoded.references.size(), 1u);
    EXPECT_EQ(decoded.references[0].ref_type, 0);  // CHILD_OF
    EXPECT_EQ(decoded.references[0].span_id.size(), 8u);
}

References kcenon::monitoring::jaeger_exporter::convert_span(), kcenon::monitoring::jaeger_proto::decode_span(), kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::trace_export_config::format, kcenon::monitoring::jaeger_proto::span::references, and kcenon::monitoring::jaeger_span_data::to_protobuf().

Here is the call graph for this function:

TEST_F() [17/27]

TEST_F	(	TraceExportersTest	,
		JaegerSpanProtobufRoundTrip	)

Definition at line 417 of file test_trace_exporters.cpp.

                                                        {
    trace_export_config config;
    config.endpoint = "http://jaeger:14268";
    config.format = trace_export_format::jaeger_grpc;
    config.service_name = "test_service";
 
    jaeger_exporter exporter(config);
    auto jaeger_span = exporter.convert_span(test_spans_[0]);
    auto wire = jaeger_span.to_protobuf();
    ASSERT_FALSE(wire.empty());
 
    kcenon::monitoring::jaeger_proto::span decoded;
    ASSERT_TRUE(kcenon::monitoring::jaeger_proto::decode_span(
        wire.data(), wire.size(), decoded));
 
    // Core identifiers: 16-byte trace ID, 8-byte span ID
    EXPECT_EQ(decoded.trace_id.size(), 16u);
    EXPECT_EQ(decoded.span_id.size(), 8u);
    EXPECT_EQ(decoded.operation_name, test_spans_[0].operation_name);
 
    // Tags preserved (STRING ValueType).
    bool found_method = false, found_url = false, found_kind = false;
    for (const auto& kv : decoded.tags) {
        if (kv.key == "http.method") {
            EXPECT_EQ(kv.v_str, "GET");
            EXPECT_EQ(static_cast<int>(kv.v_type), 0);
            found_method = true;
        } else if (kv.key == "http.url") {
            EXPECT_EQ(kv.v_str, "/api/users");
            found_url = true;
        } else if (kv.key == "span.kind") {
            EXPECT_EQ(kv.v_str, "server");
            found_kind = true;
        }
    }
    EXPECT_TRUE(found_method);
    EXPECT_TRUE(found_url);
    EXPECT_TRUE(found_kind);
 
    // Process service name overridden from config.
    EXPECT_EQ(decoded.proc.service_name, "test_service");
}

References kcenon::monitoring::jaeger_exporter::convert_span(), kcenon::monitoring::jaeger_proto::decode_span(), kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::trace_export_config::format, kcenon::monitoring::jaeger_proto::span::operation_name, kcenon::monitoring::jaeger_proto::span::proc, kcenon::monitoring::jaeger_proto::process::service_name, kcenon::monitoring::trace_export_config::service_name, kcenon::monitoring::jaeger_proto::span::span_id, kcenon::monitoring::jaeger_proto::span::tags, kcenon::monitoring::jaeger_span_data::to_protobuf(), and kcenon::monitoring::jaeger_proto::span::trace_id.

Here is the call graph for this function:

TEST_F() [18/27]

TEST_F	(	TraceExportersTest	,
		LargeSpanBatch	)

Definition at line 349 of file test_trace_exporters.cpp.

                                           {
    // Create a large batch of spans
    std::vector<trace_span> large_batch;
    for (int i = 0; i < 1000; ++i) {
        trace_span span;
        span.trace_id = "trace" + std::to_string(i);
        span.span_id = "span" + std::to_string(i);
        span.operation_name = "operation_" + std::to_string(i);
        span.service_name = "test_service";
        span.start_time = std::chrono::system_clock::now();
        span.end_time = span.start_time + std::chrono::milliseconds(1);
        large_batch.push_back(span);
    }
 
    trace_export_config config;
    config.endpoint = "http://test:1234";
    config.format = trace_export_format::otlp_grpc;
    config.max_batch_size = 500; // Smaller than batch size
 
    otlp_exporter exporter(config, otel_resource_);
    auto result = exporter.export_spans(large_batch);
    EXPECT_TRUE(result.is_ok());
 
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_spans"], static_cast<std::size_t>(1000));
}

References kcenon::monitoring::trace_span::end_time, kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::otlp_exporter::export_spans(), kcenon::monitoring::trace_export_config::format, kcenon::monitoring::otlp_exporter::get_stats(), kcenon::monitoring::trace_export_config::max_batch_size, kcenon::monitoring::trace_span::operation_name, kcenon::monitoring::trace_span::service_name, kcenon::monitoring::trace_span::span_id, kcenon::monitoring::trace_span::start_time, and kcenon::monitoring::trace_span::trace_id.

Here is the call graph for this function:

TEST_F() [19/27]

TEST_F	(	TraceExportersTest	,
		OtlpExporterBasicFunctionality	)

Definition at line 214 of file test_trace_exporters.cpp.

                                                           {
    trace_export_config config;
    config.endpoint = "http://otlp-collector:4317";
    config.format = trace_export_format::otlp_grpc;
 
    otlp_exporter exporter(config, otel_resource_);
 
    // Export spans
    auto export_result = exporter.export_spans(test_spans_);
    EXPECT_TRUE(export_result.is_ok());
 
    // Check statistics
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["exported_spans"], test_spans_.size());
    EXPECT_EQ(stats["failed_exports"], 0);
 
    // Test flush and shutdown
    auto flush_result = exporter.flush();
    EXPECT_TRUE(flush_result.is_ok());
 
    auto shutdown_result = exporter.shutdown();
    EXPECT_TRUE(shutdown_result.is_ok());
}

References kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::otlp_exporter::export_spans(), kcenon::monitoring::otlp_exporter::flush(), kcenon::monitoring::trace_export_config::format, kcenon::monitoring::otlp_exporter::get_stats(), and kcenon::monitoring::otlp_exporter::shutdown().

Here is the call graph for this function:

TEST_F() [20/27]

TEST_F	(	TraceExportersTest	,
		SupportedFormatsQuery	)

Definition at line 264 of file test_trace_exporters.cpp.

                                                  {
    auto jaeger_formats = trace_exporter_factory::get_supported_formats("jaeger");
    EXPECT_EQ(jaeger_formats.size(), 2);
    EXPECT_TRUE(std::find(jaeger_formats.begin(), jaeger_formats.end(), 
                         trace_export_format::jaeger_thrift) != jaeger_formats.end());
    EXPECT_TRUE(std::find(jaeger_formats.begin(), jaeger_formats.end(), 
                         trace_export_format::jaeger_grpc) != jaeger_formats.end());
    
    auto zipkin_formats = trace_exporter_factory::get_supported_formats("zipkin");
    EXPECT_EQ(zipkin_formats.size(), 2);
    EXPECT_TRUE(std::find(zipkin_formats.begin(), zipkin_formats.end(), 
                         trace_export_format::zipkin_json) != zipkin_formats.end());
    EXPECT_TRUE(std::find(zipkin_formats.begin(), zipkin_formats.end(), 
                         trace_export_format::zipkin_protobuf) != zipkin_formats.end());
    
    auto otlp_formats = trace_exporter_factory::get_supported_formats("otlp");
    EXPECT_EQ(otlp_formats.size(), 3);
    EXPECT_TRUE(std::find(otlp_formats.begin(), otlp_formats.end(), 
                         trace_export_format::otlp_grpc) != otlp_formats.end());
    
    auto unknown_formats = trace_exporter_factory::get_supported_formats("unknown");
    EXPECT_EQ(unknown_formats.size(), 0);
}

References kcenon::monitoring::trace_exporter_factory::get_supported_formats().

Here is the call graph for this function:

TEST_F() [21/27]

TEST_F	(	TraceExportersTest	,
		TraceExportConfigValidation	)

Definition at line 63 of file test_trace_exporters.cpp.

                                                        {
    // Valid configuration
    trace_export_config valid_config;
    valid_config.endpoint = "http://jaeger:14268/api/traces";
    valid_config.format = trace_export_format::jaeger_thrift;
    valid_config.timeout = std::chrono::milliseconds(5000);
    valid_config.max_batch_size = 100;
    valid_config.max_queue_size = 1000;
 
    auto validation = valid_config.validate();
    EXPECT_TRUE(validation.is_ok());
 
    // Invalid endpoint
    trace_export_config invalid_endpoint;
    invalid_endpoint.endpoint = "";
    auto endpoint_validation = invalid_endpoint.validate();
    EXPECT_TRUE(endpoint_validation.is_err());
    EXPECT_EQ(endpoint_validation.error().code, static_cast<int>(monitoring_error_code::invalid_configuration));
 
    // Invalid timeout
    trace_export_config invalid_timeout;
    invalid_timeout.endpoint = "http://test";
    invalid_timeout.timeout = std::chrono::milliseconds(0);
    auto timeout_validation = invalid_timeout.validate();
    EXPECT_TRUE(timeout_validation.is_err());
 
    // Invalid batch size
    trace_export_config invalid_batch;
    invalid_batch.endpoint = "http://test";
    invalid_batch.max_batch_size = 0;
    auto batch_validation = invalid_batch.validate();
    EXPECT_TRUE(batch_validation.is_err());
 
    // Invalid queue size
    trace_export_config invalid_queue;
    invalid_queue.endpoint = "http://test";
    invalid_queue.max_batch_size = 100;
    invalid_queue.max_queue_size = 50;
    auto queue_validation = invalid_queue.validate();
    EXPECT_TRUE(queue_validation.is_err());
}

References kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::trace_export_config::format, kcenon::monitoring::trace_export_config::max_batch_size, kcenon::monitoring::trace_export_config::max_queue_size, kcenon::monitoring::trace_export_config::timeout, and kcenon::monitoring::trace_export_config::validate().

Here is the call graph for this function:

TEST_F() [22/27]

TEST_F	(	TraceExportersTest	,
		TraceExporterFactory	)

Definition at line 238 of file test_trace_exporters.cpp.

                                                 {
    // Test Jaeger factory
    trace_export_config jaeger_config;
    jaeger_config.endpoint = "http://jaeger:14268";
    jaeger_config.format = trace_export_format::jaeger_grpc;
    
    auto jaeger_exporter = trace_exporter_factory::create_exporter(jaeger_config, otel_resource_);
    EXPECT_TRUE(jaeger_exporter);
    
    // Test Zipkin factory
    trace_export_config zipkin_config;
    zipkin_config.endpoint = "http://zipkin:9411";
    zipkin_config.format = trace_export_format::zipkin_json;
    
    auto zipkin_exporter = trace_exporter_factory::create_exporter(zipkin_config, otel_resource_);
    EXPECT_TRUE(zipkin_exporter);
    
    // Test OTLP factory
    trace_export_config otlp_config;
    otlp_config.endpoint = "http://otlp-collector:4317";
    otlp_config.format = trace_export_format::otlp_grpc;
    
    auto otlp_exporter = trace_exporter_factory::create_exporter(otlp_config, otel_resource_);
    EXPECT_TRUE(otlp_exporter);
}

References kcenon::monitoring::trace_exporter_factory::create_exporter(), kcenon::monitoring::trace_export_config::endpoint, and kcenon::monitoring::trace_export_config::format.

Here is the call graph for this function:

TEST_F() [23/27]

TEST_F	(	TraceExportersTest	,
		ZipkinExporterBasicFunctionality	)

Definition at line 191 of file test_trace_exporters.cpp.

                                                             {
    trace_export_config config;
    config.endpoint = "http://zipkin:9411/api/v2/spans";
    config.format = trace_export_format::zipkin_json;
 
    zipkin_exporter exporter(config);
 
    // Export spans — stub transport returns error (no real HTTP client)
    auto export_result = exporter.export_spans(test_spans_);
    EXPECT_TRUE(export_result.is_err());
 
    // Check statistics — export failed
    auto stats = exporter.get_stats();
    EXPECT_EQ(stats["failed_exports"], 1);
 
    // Test flush and shutdown (should still work)
    auto flush_result = exporter.flush();
    EXPECT_TRUE(flush_result.is_ok());
 
    auto shutdown_result = exporter.shutdown();
    EXPECT_TRUE(shutdown_result.is_ok());
}

References kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::zipkin_exporter::export_spans(), kcenon::monitoring::zipkin_exporter::flush(), kcenon::monitoring::trace_export_config::format, kcenon::monitoring::zipkin_exporter::get_stats(), and kcenon::monitoring::zipkin_exporter::shutdown().

Here is the call graph for this function:

TEST_F() [24/27]

TEST_F	(	TraceExportersTest	,
		ZipkinListOfSpansRoundTrip	)

Definition at line 551 of file test_trace_exporters.cpp.

                                                       {
    trace_export_config config;
    config.endpoint = "http://zipkin:9411";
    config.format = trace_export_format::zipkin_protobuf;
    config.service_name = "test_service";
 
    zipkin_exporter exporter(config);
    std::vector<zipkin_span_data> zipkin_spans;
    for (const auto& s : test_spans_) {
        zipkin_spans.push_back(exporter.convert_span(s));
    }
    auto wire = encode_zipkin_list_of_spans(zipkin_spans);
    ASSERT_FALSE(wire.empty());
 
    kcenon::monitoring::zipkin_proto::list_of_spans decoded;
    ASSERT_TRUE(kcenon::monitoring::zipkin_proto::decode_list_of_spans(
        wire.data(), wire.size(), decoded));
    EXPECT_EQ(decoded.spans.size(), test_spans_.size());
}

References kcenon::monitoring::zipkin_exporter::convert_span(), kcenon::monitoring::zipkin_proto::decode_list_of_spans(), kcenon::monitoring::encode_zipkin_list_of_spans(), kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::trace_export_config::format, kcenon::monitoring::trace_export_config::service_name, and kcenon::monitoring::zipkin_proto::list_of_spans::spans.

Here is the call graph for this function:

TEST_F() [25/27]

TEST_F	(	TraceExportersTest	,
		ZipkinSpanConversion	)

Definition at line 168 of file test_trace_exporters.cpp.

                                                 {
    trace_export_config config;
    config.endpoint = "http://zipkin:9411/api/v2/spans";
    config.format = trace_export_format::zipkin_json;
    config.service_name = "test_service";
    
    zipkin_exporter exporter(config);
    
    const auto& span = test_spans_[0];
    auto zipkin_span = exporter.convert_span(span);
    
    EXPECT_EQ(zipkin_span.trace_id, span.trace_id);
    EXPECT_EQ(zipkin_span.span_id, span.span_id);
    EXPECT_EQ(zipkin_span.name, span.operation_name);
    EXPECT_EQ(zipkin_span.local_endpoint_service_name, "test_service");
    EXPECT_EQ(zipkin_span.kind, "server"); // From span.kind tag
    
    // Check tags conversion (span.kind should be excluded)
    EXPECT_EQ(zipkin_span.tags.count("span.kind"), 0);
    EXPECT_EQ(zipkin_span.tags.count("http.method"), 1);
    EXPECT_EQ(zipkin_span.tags["http.method"], "GET");
}

References kcenon::monitoring::zipkin_exporter::convert_span(), kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::trace_export_config::format, and kcenon::monitoring::trace_export_config::service_name.

Here is the call graph for this function:

TEST_F() [26/27]

TEST_F	(	TraceExportersTest	,
		ZipkinSpanProtobufParent	)

Definition at line 535 of file test_trace_exporters.cpp.

                                                     {
    trace_export_config config;
    config.endpoint = "http://zipkin:9411";
    config.format = trace_export_format::zipkin_protobuf;
 
    zipkin_exporter exporter(config);
    auto zipkin_span = exporter.convert_span(test_spans_[1]);
    auto wire = zipkin_span.to_protobuf();
 
    kcenon::monitoring::zipkin_proto::span decoded;
    ASSERT_TRUE(kcenon::monitoring::zipkin_proto::decode_span(
        wire.data(), wire.size(), decoded));
    EXPECT_EQ(decoded.parent_id.size(), 8u);
    EXPECT_EQ(decoded.kind, kcenon::monitoring::zipkin_proto::span_kind::client);
}

References kcenon::monitoring::zipkin_proto::client, kcenon::monitoring::zipkin_exporter::convert_span(), kcenon::monitoring::zipkin_proto::decode_span(), kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::trace_export_config::format, kcenon::monitoring::zipkin_proto::span::kind, kcenon::monitoring::zipkin_proto::span::parent_id, and kcenon::monitoring::zipkin_span_data::to_protobuf().

Here is the call graph for this function:

TEST_F() [27/27]

TEST_F	(	TraceExportersTest	,
		ZipkinSpanProtobufRoundTrip	)

Definition at line 501 of file test_trace_exporters.cpp.

                                                        {
    trace_export_config config;
    config.endpoint = "http://zipkin:9411";
    config.format = trace_export_format::zipkin_protobuf;
    config.service_name = "test_service";
 
    zipkin_exporter exporter(config);
    auto zipkin_span = exporter.convert_span(test_spans_[0]);
    auto wire = zipkin_span.to_protobuf();
    ASSERT_FALSE(wire.empty());
 
    kcenon::monitoring::zipkin_proto::span decoded;
    ASSERT_TRUE(kcenon::monitoring::zipkin_proto::decode_span(
        wire.data(), wire.size(), decoded));
 
    // Trace ID length: 8 or 16; span ID: 8 bytes.
    EXPECT_TRUE(decoded.trace_id.size() == 8u || decoded.trace_id.size() == 16u);
    EXPECT_EQ(decoded.id.size(), 8u);
    EXPECT_EQ(decoded.name, "http_request");
    EXPECT_EQ(decoded.kind, kcenon::monitoring::zipkin_proto::span_kind::server);
    EXPECT_EQ(decoded.local_endpoint.service_name, "test_service");
 
    // Tags preserved; span.kind excluded by convert_span.
    bool found_method = false, found_url = false, found_kind = false;
    for (const auto& [k, v] : decoded.tags) {
        if (k == "http.method") { EXPECT_EQ(v, "GET"); found_method = true; }
        if (k == "http.url") { EXPECT_EQ(v, "/api/users"); found_url = true; }
        if (k == "span.kind") { found_kind = true; }
    }
    EXPECT_TRUE(found_method);
    EXPECT_TRUE(found_url);
    EXPECT_FALSE(found_kind);
}

References kcenon::monitoring::zipkin_exporter::convert_span(), kcenon::monitoring::zipkin_proto::decode_span(), kcenon::monitoring::trace_export_config::endpoint, kcenon::monitoring::trace_export_config::format, 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::server, kcenon::monitoring::trace_export_config::service_name, kcenon::monitoring::zipkin_proto::endpoint::service_name, kcenon::monitoring::zipkin_proto::span::tags, kcenon::monitoring::zipkin_span_data::to_protobuf(), and kcenon::monitoring::zipkin_proto::span::trace_id.

Here is the call graph for this function: