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/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_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_F() [1/21]

TEST_F	(	OtlpGrpcExporterTest	,
		ConfigValidation	)

Definition at line 389 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/21]

TEST_F	(	OtlpGrpcExporterTest	,
		ExportEmptySpans	)

Definition at line 599 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/21]

TEST_F	(	OtlpGrpcExporterTest	,
		ExporterDetailedStats	)

Definition at line 543 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/21]

TEST_F	(	OtlpGrpcExporterTest	,
		ExporterFailedConnection	)

Definition at line 487 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/21]

TEST_F	(	OtlpGrpcExporterTest	,
		ExporterRetryBehavior	)

Definition at line 502 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/21]

TEST_F	(	OtlpGrpcExporterTest	,
		ExporterWithStubTransport	)

Definition at line 449 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/21]

TEST_F	(	OtlpGrpcExporterTest	,
		FactoryFunctions	)

Definition at line 575 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/21]

TEST_F	(	OtlpGrpcExporterTest	,
		SpanConverterBasic	)

Definition at line 420 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/21]

TEST_F	(	OtlpGrpcExporterTest	,
		SpanConverterEmptySpans	)

Definition at line 436 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/21]

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/21]

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/21]

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/21]

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() [14/21]

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() [15/21]

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() [16/21]

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() [17/21]

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() [18/21]

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() [19/21]

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() [20/21]

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() [21/21]

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: