test_distributed_tracing.cpp File Reference

Unit tests for distributed tracing functionality. More...

#include <gtest/gtest.h>
#include <thread>
#include <chrono>
#include <unordered_map>
#include <kcenon/monitoring/tracing/distributed_tracer.h>
#include <kcenon/monitoring/exporters/trace_exporters.h>

Include dependency graph for test_distributed_tracing.cpp:

Go to the source code of this file.

Classes
class	DistributedTracingTest
class	MockTraceExporter
class	ExporterIntegrationTest

Functions
	TEST_F (DistributedTracingTest, CreateRootSpan)
	TEST_F (DistributedTracingTest, CreateChildSpan)
	TEST_F (DistributedTracingTest, FinishSpan)
	TEST_F (DistributedTracingTest, CannotFinishSpanTwice)
	TEST_F (DistributedTracingTest, TraceContextPropagation)
	TEST_F (DistributedTracingTest, W3CTraceContextFormat)
	TEST_F (DistributedTracingTest, InjectExtractContext)
	TEST_F (DistributedTracingTest, StartSpanFromContext)
	TEST_F (DistributedTracingTest, CurrentSpanManagement)
	TEST_F (DistributedTracingTest, ScopedSpan)
	TEST_F (DistributedTracingTest, GetTrace)
	TEST_F (DistributedTracingTest, SpanTags)
	TEST_F (DistributedTracingTest, SpanStatus)
	TEST_F (DistributedTracingTest, BaggagePropagation)
	TEST_F (DistributedTracingTest, ExportSpans)
	TEST_F (DistributedTracingTest, TraceMacros)
	TEST_F (ExporterIntegrationTest, SetAndGetExporter)
	TEST_F (ExporterIntegrationTest, ConfigureExportSettings)
	TEST_F (ExporterIntegrationTest, AutoExportWhenBatchSizeReached)
	TEST_F (ExporterIntegrationTest, ManualFlush)
	TEST_F (ExporterIntegrationTest, FlushWithNoExporter)
	TEST_F (ExporterIntegrationTest, ExportFailureRetainsSpans)
	TEST_F (ExporterIntegrationTest, ExportStats)
	TEST_F (ExporterIntegrationTest, QueueSizeLimitEnforced)
	TEST_F (ExporterIntegrationTest, ExportedSpansContainCorrectData)

Detailed Description

Unit tests for distributed tracing functionality.

Definition in file test_distributed_tracing.cpp.

Function Documentation

TEST_F() [1/25]

TEST_F	(	DistributedTracingTest	,
		BaggagePropagation	)

Definition at line 285 of file test_distributed_tracing.cpp.

                                                   {
    auto parent_result = tracer.start_span("parent");
    ASSERT_TRUE(parent_result.is_ok());
    auto parent = parent_result.value();
    
    parent->baggage["session_id"] = "abc123";
    parent->baggage["feature_flag"] = "enabled";
    
    auto child_result = tracer.start_child_span(*parent, "child");
    ASSERT_TRUE(child_result.is_ok());
    auto child = child_result.value();
    
    // Child should inherit baggage
    EXPECT_EQ(child->baggage["session_id"], "abc123");
    EXPECT_EQ(child->baggage["feature_flag"], "enabled");
    
    // Child can add its own baggage
    child->baggage["child_data"] = "xyz";
    
    auto grandchild_result = tracer.start_child_span(*child, "grandchild");
    ASSERT_TRUE(grandchild_result.is_ok());
    auto grandchild = grandchild_result.value();
    
    // Grandchild should have all baggage
    EXPECT_EQ(grandchild->baggage["session_id"], "abc123");
    EXPECT_EQ(grandchild->baggage["feature_flag"], "enabled");
    EXPECT_EQ(grandchild->baggage["child_data"], "xyz");
}

TEST_F() [2/25]

TEST_F	(	DistributedTracingTest	,
		CannotFinishSpanTwice	)

Definition at line 76 of file test_distributed_tracing.cpp.

                                                      {
    auto span_result = tracer.start_span("test_operation");
    ASSERT_TRUE(span_result.is_ok());
    auto span = span_result.value();
 
    auto first_finish = tracer.finish_span(span);
    ASSERT_TRUE(first_finish.is_ok());
 
    auto second_finish = tracer.finish_span(span);
    ASSERT_TRUE(second_finish.is_err());
}

TEST_F() [3/25]

TEST_F	(	DistributedTracingTest	,
		CreateChildSpan	)

Definition at line 45 of file test_distributed_tracing.cpp.

                                                {
    auto parent_result = tracer.start_span("parent_operation");
    ASSERT_TRUE(parent_result.is_ok());
    auto parent = parent_result.value();
    
    auto child_result = tracer.start_child_span(*parent, "child_operation");
    ASSERT_TRUE(child_result.is_ok());
    auto child = child_result.value();
    
    EXPECT_EQ(child->trace_id, parent->trace_id);
    EXPECT_NE(child->span_id, parent->span_id);
    EXPECT_EQ(child->parent_span_id, parent->span_id);
    EXPECT_EQ(child->operation_name, "child_operation");
}

TEST_F() [4/25]

TEST_F	(	DistributedTracingTest	,
		CreateRootSpan	)

Definition at line 32 of file test_distributed_tracing.cpp.

                                               {
    auto span_result = tracer.start_span("test_operation", "test_service");
    ASSERT_TRUE(span_result.is_ok());
    
    auto span = span_result.value();
    EXPECT_FALSE(span->trace_id.empty());
    EXPECT_FALSE(span->span_id.empty());
    EXPECT_TRUE(span->parent_span_id.empty());
    EXPECT_EQ(span->operation_name, "test_operation");
    EXPECT_EQ(span->service_name, "test_service");
    EXPECT_FALSE(span->is_finished());
}

TEST_F() [5/25]

TEST_F	(	DistributedTracingTest	,
		CurrentSpanManagement	)

Definition at line 174 of file test_distributed_tracing.cpp.

                                                      {
    EXPECT_EQ(tracer.get_current_span(), nullptr);
    
    auto span_result = tracer.start_span("test_operation");
    ASSERT_TRUE(span_result.is_ok());
    auto span = span_result.value();
    
    tracer.set_current_span(span);
    EXPECT_EQ(tracer.get_current_span(), span);
    
    // Different thread should have different current span
    std::thread other_thread([&]() {
        EXPECT_EQ(tracer.get_current_span(), nullptr);
        
        auto other_span_result = tracer.start_span("other_operation");
        ASSERT_TRUE(other_span_result.is_ok());
        auto other_span = other_span_result.value();
        
        tracer.set_current_span(other_span);
        EXPECT_EQ(tracer.get_current_span(), other_span);
    });
    other_thread.join();
    
    // Original thread should still have its span
    EXPECT_EQ(tracer.get_current_span(), span);
}

TEST_F() [6/25]

TEST_F	(	DistributedTracingTest	,
		ExportSpans	)

Definition at line 314 of file test_distributed_tracing.cpp.

                                            {
    std::vector<trace_span> spans_to_export;
    
    // Create and finish spans
    for (int i = 0; i < 5; ++i) {
        auto span_result = tracer.start_span("operation_" + std::to_string(i));
        ASSERT_TRUE(span_result.is_ok());
        auto span = span_result.value();
        
        tracer.finish_span(span);
        spans_to_export.push_back(*span);
    }
    
    auto export_result = tracer.export_spans(spans_to_export);
    ASSERT_TRUE(export_result.is_ok());
    
    // Verify spans were stored
    auto trace_result = tracer.get_trace(spans_to_export[0].trace_id);
    ASSERT_TRUE(trace_result.is_ok());
    auto trace = trace_result.value();
    
    // Note: In this test, all spans have different trace IDs
    // In a real scenario, they might be part of the same trace
}

TEST_F() [7/25]

TEST_F	(	DistributedTracingTest	,
		FinishSpan	)

Definition at line 60 of file test_distributed_tracing.cpp.

                                           {
    auto span_result = tracer.start_span("test_operation");
    ASSERT_TRUE(span_result.is_ok());
    auto span = span_result.value();
    
    // Add some delay to have measurable duration
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
    
    auto finish_result = tracer.finish_span(span);
    ASSERT_TRUE(finish_result.is_ok());
    
    EXPECT_TRUE(span->is_finished());
    EXPECT_GT(span->duration.count(), 0);
    EXPECT_EQ(span->status, trace_span::status_code::ok);
}

TEST_F() [8/25]

TEST_F	(	DistributedTracingTest	,
		GetTrace	)

Definition at line 217 of file test_distributed_tracing.cpp.

                                         {
    auto span1_result = tracer.start_span("operation1");
    ASSERT_TRUE(span1_result.is_ok());
    auto span1 = span1_result.value();
    
    auto span2_result = tracer.start_child_span(*span1, "operation2");
    ASSERT_TRUE(span2_result.is_ok());
    auto span2 = span2_result.value();
    
    auto span3_result = tracer.start_child_span(*span2, "operation3");
    ASSERT_TRUE(span3_result.is_ok());
    auto span3 = span3_result.value();
    
    // Finish all spans
    tracer.finish_span(span1);
    tracer.finish_span(span2);
    tracer.finish_span(span3);
    
    // Get all spans for the trace
    auto trace_result = tracer.get_trace(span1->trace_id);
    ASSERT_TRUE(trace_result.is_ok());
    auto trace = trace_result.value();
    
    EXPECT_EQ(trace.size(), 3);
    
    // All spans should have the same trace ID
    for (const auto& span : trace) {
        EXPECT_EQ(span.trace_id, span1->trace_id);
        EXPECT_TRUE(span.is_finished());
    }
}

TEST_F() [9/25]

TEST_F	(	DistributedTracingTest	,
		InjectExtractContext	)

Definition at line 124 of file test_distributed_tracing.cpp.

                                                     {
    auto span_result = tracer.start_span("test_operation");
    ASSERT_TRUE(span_result.is_ok());
    auto span = span_result.value();
 
    span->baggage["test_key"] = "test_value";
 
    // Inject into carrier (simulating HTTP headers)
    std::unordered_map<std::string, std::string> headers;
    auto context = tracer.extract_context(*span);
    tracer.inject_context(context, headers);
 
    EXPECT_TRUE(headers.contains("traceparent"));
    EXPECT_TRUE(headers.contains("baggage-test_key"));
 
    // Verify traceparent header format (00-traceid-spanid-flags)
    auto traceparent = headers["traceparent"];
    EXPECT_EQ(traceparent.substr(0, 3), "00-");
    EXPECT_FALSE(traceparent.empty());
 
    // Extract from carrier
    auto extracted_result = tracer.extract_context_from_carrier(headers);
    ASSERT_TRUE(extracted_result.is_ok());
    auto extracted = extracted_result.value();
 
    // Verify baggage is preserved through inject/extract cycle
    EXPECT_EQ(extracted.baggage["test_key"], "test_value");
 
    // Verify trace_id and span_id are extracted (may differ from original due to W3C format)
    EXPECT_FALSE(extracted.trace_id.empty());
    EXPECT_FALSE(extracted.span_id.empty());
}

TEST_F() [10/25]

TEST_F	(	DistributedTracingTest	,
		ScopedSpan	)

Definition at line 201 of file test_distributed_tracing.cpp.

                                           {
    {
        auto span_result = tracer.start_span("scoped_operation");
        ASSERT_TRUE(span_result.is_ok());
        scoped_span scoped(span_result.value(), &tracer);
        
        EXPECT_EQ(tracer.get_current_span(), span_result.value());
        EXPECT_FALSE(scoped->is_finished());
        
        // Span should be accessible via scoped object
        scoped->tags["custom_tag"] = "custom_value";
    }
    // Span should be finished after leaving scope
    // Note: We can't directly check as the span is finished and stored
}

References kcenon::monitoring::trace_span::is_finished(), and kcenon::monitoring::trace_span::tags.

Here is the call graph for this function:

TEST_F() [11/25]

TEST_F	(	DistributedTracingTest	,
		SpanStatus	)

Definition at line 268 of file test_distributed_tracing.cpp.

                                           {
    auto span_result = tracer.start_span("status_operation");
    ASSERT_TRUE(span_result.is_ok());
    auto span = span_result.value();
    
    EXPECT_EQ(span->status, trace_span::status_code::unset);
    
    // Set error status
    span->status = trace_span::status_code::error;
    span->status_message = "Operation failed due to timeout";
    
    tracer.finish_span(span);
    
    EXPECT_EQ(span->status, trace_span::status_code::error);
    EXPECT_EQ(span->status_message, "Operation failed due to timeout");
}

TEST_F() [12/25]

TEST_F	(	DistributedTracingTest	,
		SpanTags	)

Definition at line 249 of file test_distributed_tracing.cpp.

                                         {
    auto span_result = tracer.start_span("tagged_operation", "my_service");
    ASSERT_TRUE(span_result.is_ok());
    auto span = span_result.value();
    
    // Check default tags
    EXPECT_EQ(span->tags["span.kind"], "internal");
    EXPECT_EQ(span->tags["service.name"], "my_service");
    
    // Add custom tags
    span->tags["http.method"] = "GET";
    span->tags["http.status_code"] = "200";
    span->tags["user.id"] = "user123";
    
    EXPECT_EQ(span->tags["http.method"], "GET");
    EXPECT_EQ(span->tags["http.status_code"], "200");
    EXPECT_EQ(span->tags["user.id"], "user123");
}

TEST_F() [13/25]

TEST_F	(	DistributedTracingTest	,
		StartSpanFromContext	)

Definition at line 157 of file test_distributed_tracing.cpp.

                                                     {
    // Simulate incoming request with trace context
    trace_context incoming_ctx;
    incoming_ctx.trace_id = "0af7651916cd43dd8448eb211c80319c";
    incoming_ctx.span_id = "b7ad6b7169203331";
    incoming_ctx.baggage["user_id"] = "67890";
    
    auto span_result = tracer.start_span_from_context(incoming_ctx, "handle_request");
    ASSERT_TRUE(span_result.is_ok());
    auto span = span_result.value();
    
    EXPECT_EQ(span->trace_id, incoming_ctx.trace_id);
    EXPECT_NE(span->span_id, incoming_ctx.span_id);  // New span ID
    EXPECT_EQ(span->parent_span_id, incoming_ctx.span_id);
    EXPECT_EQ(span->baggage["user_id"], "67890");
}

References kcenon::monitoring::trace_context::baggage, kcenon::monitoring::trace_context::span_id, and kcenon::monitoring::trace_context::trace_id.

TEST_F() [14/25]

TEST_F	(	DistributedTracingTest	,
		TraceContextPropagation	)

Definition at line 88 of file test_distributed_tracing.cpp.

                                                        {
    auto span_result = tracer.start_span("test_operation");
    ASSERT_TRUE(span_result.is_ok());
    auto span = span_result.value();
    
    // Add baggage
    span->baggage["user_id"] = "12345";
    span->baggage["request_type"] = "api";
    
    // Extract context - explicitly use const trace_span&
    const trace_span& span_ref = *span;
    auto context = tracer.extract_context(span_ref);
    EXPECT_EQ(context.trace_id, span->trace_id);
    EXPECT_EQ(context.span_id, span->span_id);
    EXPECT_EQ(context.baggage["user_id"], "12345");
    EXPECT_EQ(context.baggage["request_type"], "api");
}

TEST_F() [15/25]

TEST_F	(	DistributedTracingTest	,
		TraceMacros	)

Definition at line 340 of file test_distributed_tracing.cpp.

                                            {
    {
        TRACE_SPAN("macro_operation");
        
        // The span should be active
        auto current = global_tracer().get_current_span();
        ASSERT_NE(current, nullptr);
        EXPECT_EQ(current->operation_name, "macro_operation");
        
        // Nested span
        {
            TRACE_CHILD_SPAN(*current, "nested_operation");
            auto nested = global_tracer().get_current_span();
            ASSERT_NE(nested, nullptr);
            EXPECT_EQ(nested->operation_name, "nested_operation");
            EXPECT_EQ(nested->parent_span_id, current->span_id);
        }
    }
    // Spans should be finished after leaving scope
}

References kcenon::monitoring::distributed_tracer::get_current_span(), kcenon::monitoring::global_tracer(), TRACE_CHILD_SPAN, and TRACE_SPAN.

Here is the call graph for this function:

TEST_F() [16/25]

TEST_F	(	DistributedTracingTest	,
		W3CTraceContextFormat	)

Definition at line 106 of file test_distributed_tracing.cpp.

                                                      {
    trace_context ctx;
    ctx.trace_id = "0af7651916cd43dd8448eb211c80319c";
    ctx.span_id = "b7ad6b7169203331";
    ctx.trace_flags = "01";
    
    auto header = ctx.to_w3c_traceparent();
    EXPECT_EQ(header, "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01");
    
    auto parsed_result = trace_context::from_w3c_traceparent(header);
    ASSERT_TRUE(parsed_result.is_ok());
    auto parsed = parsed_result.value();
    
    EXPECT_EQ(parsed.trace_id, ctx.trace_id);
    EXPECT_EQ(parsed.span_id, ctx.span_id);
    EXPECT_EQ(parsed.trace_flags, ctx.trace_flags);
}

References kcenon::monitoring::trace_context::from_w3c_traceparent(), kcenon::monitoring::trace_context::span_id, kcenon::monitoring::trace_context::to_w3c_traceparent(), kcenon::monitoring::trace_context::trace_flags, and kcenon::monitoring::trace_context::trace_id.

Here is the call graph for this function:

TEST_F() [17/25]

TEST_F	(	ExporterIntegrationTest	,
		AutoExportWhenBatchSizeReached	)

Definition at line 440 of file test_distributed_tracing.cpp.

                                                                {
    tracer.set_exporter(mock_exporter);
 
    trace_export_settings settings;
    settings.batch_size = 5;
    settings.export_on_finish = true;
    tracer.configure_export(settings);
 
    // Create and finish enough spans to trigger export
    for (int i = 0; i < 5; ++i) {
        auto span_result = tracer.start_span("operation_" + std::to_string(i));
        ASSERT_TRUE(span_result.is_ok());
        tracer.finish_span(span_result.value());
    }
 
    // Should have triggered one export
    EXPECT_EQ(mock_exporter->export_count.load(), 1);
    EXPECT_EQ(mock_exporter->exported_spans.size(), 5);
}

References kcenon::monitoring::trace_export_settings::batch_size, and kcenon::monitoring::trace_export_settings::export_on_finish.

TEST_F() [18/25]

TEST_F	(	ExporterIntegrationTest	,
		ConfigureExportSettings	)

Definition at line 426 of file test_distributed_tracing.cpp.

                                                         {
    trace_export_settings settings;
    settings.batch_size = 50;
    settings.max_queue_size = 1000;
    settings.export_on_finish = true;
 
    tracer.configure_export(settings);
 
    auto retrieved = tracer.get_export_settings();
    EXPECT_EQ(retrieved.batch_size, 50);
    EXPECT_EQ(retrieved.max_queue_size, 1000);
    EXPECT_TRUE(retrieved.export_on_finish);
}

References kcenon::monitoring::trace_export_settings::batch_size, kcenon::monitoring::trace_export_settings::export_on_finish, and kcenon::monitoring::trace_export_settings::max_queue_size.

TEST_F() [19/25]

TEST_F	(	ExporterIntegrationTest	,
		ExportedSpansContainCorrectData	)

Definition at line 579 of file test_distributed_tracing.cpp.

                                                                 {
    tracer.set_exporter(mock_exporter);
 
    trace_export_settings settings;
    settings.batch_size = 1;  // Export immediately
    tracer.configure_export(settings);
 
    auto span_result = tracer.start_span("test_operation", "test_service");
    ASSERT_TRUE(span_result.is_ok());
    auto span = span_result.value();
    span->tags["custom_tag"] = "custom_value";
 
    tracer.finish_span(span);
 
    ASSERT_EQ(mock_exporter->exported_spans.size(), 1);
    const auto& exported = mock_exporter->exported_spans[0];
 
    EXPECT_EQ(exported.operation_name, "test_operation");
    EXPECT_EQ(exported.service_name, "test_service");
    EXPECT_EQ(exported.trace_id, span->trace_id);
    EXPECT_EQ(exported.span_id, span->span_id);
    auto tag_it = exported.tags.find("custom_tag");
    ASSERT_NE(tag_it, exported.tags.end());
    EXPECT_EQ(tag_it->second, "custom_value");
    EXPECT_TRUE(exported.is_finished());
}

References kcenon::monitoring::trace_export_settings::batch_size.

TEST_F() [20/25]

TEST_F	(	ExporterIntegrationTest	,
		ExportFailureRetainsSpans	)

Definition at line 503 of file test_distributed_tracing.cpp.

                                                           {
    mock_exporter->should_fail = true;
    tracer.set_exporter(mock_exporter);
 
    trace_export_settings settings;
    settings.batch_size = 100;
    settings.max_queue_size = 200;
    tracer.configure_export(settings);
 
    // Create some spans
    for (int i = 0; i < 3; ++i) {
        auto span_result = tracer.start_span("operation_" + std::to_string(i));
        ASSERT_TRUE(span_result.is_ok());
        tracer.finish_span(span_result.value());
    }
 
    // Flush should fail
    auto flush_result = tracer.flush();
    EXPECT_TRUE(flush_result.is_err());
 
    // Spans should still be in queue (we can verify via stats)
    auto stats = tracer.get_export_stats();
    EXPECT_EQ(stats["pending_spans"], 3);
 
    // Now fix the exporter and try again
    mock_exporter->should_fail = false;
    flush_result = tracer.flush();
    EXPECT_TRUE(flush_result.is_ok());
 
    // Now spans should be exported
    EXPECT_EQ(mock_exporter->exported_spans.size(), 3);
}

References kcenon::monitoring::trace_export_settings::batch_size, and kcenon::monitoring::trace_export_settings::max_queue_size.

TEST_F() [21/25]

TEST_F	(	ExporterIntegrationTest	,
		ExportStats	)

Definition at line 536 of file test_distributed_tracing.cpp.

                                             {
    tracer.set_exporter(mock_exporter);
 
    trace_export_settings settings;
    settings.batch_size = 5;
    tracer.configure_export(settings);
 
    // Create and finish spans
    for (int i = 0; i < 10; ++i) {
        auto span_result = tracer.start_span("operation_" + std::to_string(i));
        ASSERT_TRUE(span_result.is_ok());
        tracer.finish_span(span_result.value());
    }
 
    auto stats = tracer.get_export_stats();
    EXPECT_EQ(stats["exported_spans"], 10);
    EXPECT_EQ(stats["failed_exports"], 0);
    EXPECT_EQ(stats["dropped_spans"], 0);
}

References kcenon::monitoring::trace_export_settings::batch_size.

TEST_F() [22/25]

TEST_F	(	ExporterIntegrationTest	,
		FlushWithNoExporter	)

Definition at line 487 of file test_distributed_tracing.cpp.

                                                     {
    // No exporter set
    EXPECT_EQ(tracer.get_exporter(), nullptr);
 
    // Create and finish some spans
    for (int i = 0; i < 3; ++i) {
        auto span_result = tracer.start_span("operation_" + std::to_string(i));
        ASSERT_TRUE(span_result.is_ok());
        tracer.finish_span(span_result.value());
    }
 
    // Flush should succeed (just clears the buffer)
    auto flush_result = tracer.flush();
    EXPECT_TRUE(flush_result.is_ok());
}

TEST_F() [23/25]

TEST_F	(	ExporterIntegrationTest	,
		ManualFlush	)

Definition at line 460 of file test_distributed_tracing.cpp.

                                             {
    tracer.set_exporter(mock_exporter);
 
    trace_export_settings settings;
    settings.batch_size = 100;  // Large batch size to prevent auto-export
    settings.export_on_finish = true;
    tracer.configure_export(settings);
 
    // Create a few spans (less than batch size)
    for (int i = 0; i < 3; ++i) {
        auto span_result = tracer.start_span("operation_" + std::to_string(i));
        ASSERT_TRUE(span_result.is_ok());
        tracer.finish_span(span_result.value());
    }
 
    // No auto-export should have happened
    EXPECT_EQ(mock_exporter->export_count.load(), 0);
 
    // Manual flush
    auto flush_result = tracer.flush();
    ASSERT_TRUE(flush_result.is_ok());
 
    // Now spans should be exported
    EXPECT_EQ(mock_exporter->export_count.load(), 1);
    EXPECT_EQ(mock_exporter->exported_spans.size(), 3);
}

References kcenon::monitoring::trace_export_settings::batch_size, and kcenon::monitoring::trace_export_settings::export_on_finish.

TEST_F() [24/25]

TEST_F	(	ExporterIntegrationTest	,
		QueueSizeLimitEnforced	)

Definition at line 556 of file test_distributed_tracing.cpp.

                                                        {
    tracer.set_exporter(mock_exporter);
    mock_exporter->should_fail = true;  // Make exports fail to fill queue
 
    trace_export_settings settings;
    settings.batch_size = 100;  // Large batch size
    settings.max_queue_size = 5;  // Small queue
    settings.export_on_finish = false;  // Disable auto-export
    tracer.configure_export(settings);
 
    // Create more spans than queue can hold
    for (int i = 0; i < 10; ++i) {
        auto span_result = tracer.start_span("operation_" + std::to_string(i));
        ASSERT_TRUE(span_result.is_ok());
        tracer.finish_span(span_result.value());
    }
 
    // Stats should show dropped spans
    auto stats = tracer.get_export_stats();
    EXPECT_GT(stats["dropped_spans"], 0);
    EXPECT_LE(stats["pending_spans"], 5);
}

References kcenon::monitoring::trace_export_settings::batch_size, kcenon::monitoring::trace_export_settings::export_on_finish, and kcenon::monitoring::trace_export_settings::max_queue_size.

TEST_F() [25/25]

TEST_F	(	ExporterIntegrationTest	,
		SetAndGetExporter	)

Definition at line 416 of file test_distributed_tracing.cpp.

                                                   {
    EXPECT_EQ(tracer.get_exporter(), nullptr);
 
    tracer.set_exporter(mock_exporter);
    EXPECT_EQ(tracer.get_exporter(), mock_exporter);
 
    tracer.set_exporter(nullptr);
    EXPECT_EQ(tracer.get_exporter(), nullptr);
}