distributed_tracing_example.cpp File Reference

Example demonstrating distributed tracing across services. More...

#include <iostream>
#include <thread>
#include <map>
#include <vector>
#include "kcenon/monitoring/tracing/distributed_tracer.h"
#include "kcenon/monitoring/context/thread_context.h"

Include dependency graph for distributed_tracing_example.cpp:

Go to the source code of this file.

Classes
class	WebService

Functions
void	simulate_distributed_system ()
void	analyze_traces (distributed_tracer &tracer)
int	main ()

Detailed Description

Example demonstrating distributed tracing across services.

Definition in file distributed_tracing_example.cpp.

Function Documentation

analyze_traces()

void analyze_traces

(

distributed_tracer &

tracer

)

Examples

distributed_tracing_example.cpp.

Definition at line 189 of file distributed_tracing_example.cpp.

                                                {
    std::cout << "\n=== Analyzing traces ===" << std::endl;
 
    // Create a sample trace for analysis
    auto root_span_result = tracer.start_span("analyze_operation", "analyzer");
    if (!root_span_result.is_ok()) return;
 
    auto root_span = root_span_result.value();
    root_span->tags["analysis.type"] = "performance";
 
    // Create multiple child spans to simulate complex operation
    std::vector<std::shared_ptr<trace_span>> child_spans;
 
    for (int i = 0; i < 5; ++i) {
        auto child_result = tracer.start_child_span(*root_span,
            "sub_operation_" + std::to_string(i));
 
        if (child_result.is_ok()) {
            auto child = child_result.value();
            child->tags["index"] = std::to_string(i);
            child->tags["complexity"] = (i % 2 == 0) ? "low" : "high";
 
            // Simulate varying durations
            std::this_thread::sleep_for(std::chrono::milliseconds(10 * (i + 1)));
 
            child_spans.push_back(child);
        }
    }
 
    // Finish all child spans
    for (auto& child : child_spans) {
        tracer.finish_span(child);
    }
 
    // Simulate an error in one operation
    auto error_span_result = tracer.start_child_span(*root_span, "failing_operation");
    if (error_span_result.is_ok()) {
        auto error_span = error_span_result.value();
        error_span->status = trace_span::status_code::error;
        error_span->status_message = "Database connection timeout";
        error_span->tags["error"] = "true";
        error_span->tags["error.type"] = "timeout";
 
        tracer.finish_span(error_span);
    }
 
    tracer.finish_span(root_span);
 
    // Get all spans for the trace
    auto trace_result = tracer.get_trace(root_span->trace_id);
    if (trace_result.is_ok()) {
        auto& spans = trace_result.value();
 
        std::cout << "Trace ID: " << root_span->trace_id << std::endl;
        std::cout << "Total spans in trace: " << spans.size() << std::endl;
 
        // Calculate total duration
        if (!spans.empty()) {
            auto min_time = spans[0].start_time;
            auto max_time = spans[0].end_time;
 
            for (const auto& span : spans) {
                if (span.start_time < min_time) min_time = span.start_time;
                if (span.end_time > max_time) max_time = span.end_time;
            }
 
            auto total_duration = std::chrono::duration_cast<std::chrono::milliseconds>(
                max_time - min_time
            );
 
            std::cout << "Total trace duration: " << total_duration.count() << " ms" << std::endl;
        }
 
        // Count errors
        int error_count = 0;
        for (const auto& span : spans) {
            if (span.status == trace_span::status_code::error) {
                error_count++;
                std::cout << "Error in span: " << span.operation_name
                         << " - " << span.status_message << std::endl;
            }
        }
 
        std::cout << "Spans with errors: " << error_count << std::endl;
    }
}

References kcenon::monitoring::distributed_tracer::finish_span(), kcenon::monitoring::distributed_tracer::get_trace(), kcenon::monitoring::distributed_tracer::start_child_span(), and kcenon::monitoring::distributed_tracer::start_span().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main

(

)

Definition at line 276 of file distributed_tracing_example.cpp.

           {
    std::cout << "=== Distributed Tracing Example ===" << std::endl;
 
    try {
        // Part 1: Basic span creation and management
        std::cout << "\n--- Part 1: Basic Span Management ---" << std::endl;
 
        distributed_tracer tracer;
 
        // Create a root span
        auto root_span_result = tracer.start_span("main_operation", "example_service");
        if (!root_span_result.is_ok()) {
            std::cerr << "Failed to create root span" << std::endl;
            return 1;
        }
 
        auto root_span = root_span_result.value();
 
        std::cout << "Created root span:" << std::endl;
        std::cout << "  Trace ID: " << root_span->trace_id << std::endl;
        std::cout << "  Span ID: " << root_span->span_id << std::endl;
        std::cout << "  Operation: " << root_span->operation_name << std::endl;
 
        // Add tags
        root_span->tags["version"] = "1.0.0";
        root_span->tags["environment"] = "development";
 
        // Add baggage (propagated to child spans)
        root_span->baggage["user.id"] = "user789";
        root_span->baggage["session.id"] = "sess123";
 
        // Create child spans
        std::cout << "\nCreating child spans..." << std::endl;
 
        auto child1_result = tracer.start_child_span(*root_span, "child_operation_1");
        auto child2_result = tracer.start_child_span(*root_span, "child_operation_2");
 
        if (child1_result.is_ok() && child2_result.is_ok()) {
            auto child1 = child1_result.value();
            auto child2 = child2_result.value();
 
            std::cout << "  Child 1 span ID: " << child1->span_id << std::endl;
            std::cout << "  Child 2 span ID: " << child2->span_id << std::endl;
 
            // Simulate some work
            std::this_thread::sleep_for(10ms);
 
            // Finish child spans
            tracer.finish_span(child1);
            tracer.finish_span(child2);
        }
 
        // Finish root span
        tracer.finish_span(root_span);
 
        std::cout << "All spans finished" << std::endl;
 
        // Part 2: Distributed system simulation
        std::cout << "\n--- Part 2: Distributed System Simulation ---" << std::endl;
        simulate_distributed_system();
 
        // Part 3: Trace analysis
        std::cout << "\n--- Part 3: Trace Analysis ---" << std::endl;
        analyze_traces(tracer);
 
        // Part 4: Context propagation demonstration
        std::cout << "\n--- Part 4: Context Propagation ---" << std::endl;
 
        auto demo_span_result = tracer.start_span("propagation_demo");
        if (demo_span_result.is_ok()) {
            auto demo_span = demo_span_result.value();
 
            // Extract context for propagation
            auto context = tracer.extract_context(*demo_span);
 
            // Simulate HTTP headers
            std::map<std::string, std::string> http_headers;
            tracer.inject_context(context, http_headers);
 
            std::cout << "Context injected into headers:" << std::endl;
            for (const auto& [key, value] : http_headers) {
                std::cout << "  " << key << ": " << value << std::endl;
            }
 
            // Simulate receiving headers in another service
            auto extracted_context = tracer.extract_context_from_carrier(http_headers);
            if (extracted_context.is_ok()) {
                std::cout << "\nContext extracted from headers:" << std::endl;
                std::cout << "  Trace ID: " << extracted_context.value().trace_id << std::endl;
                std::cout << "  Span ID: " << extracted_context.value().span_id << std::endl;
 
                // Continue trace in new service
                auto continued_span = tracer.start_span_from_context(
                    extracted_context.value(),
                    "continued_operation"
                );
 
                if (continued_span.is_ok()) {
                    std::cout << "  Continued span ID: "
                             << continued_span.value()->span_id << std::endl;
                    tracer.finish_span(continued_span.value());
                }
            }
 
            tracer.finish_span(demo_span);
        }
 
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
        return 1;
    }
 
    std::cout << "\n=== Example completed successfully ===" << std::endl;
 
    return 0;
}

References analyze_traces(), kcenon::monitoring::distributed_tracer::extract_context(), kcenon::monitoring::distributed_tracer::extract_context_from_carrier(), kcenon::monitoring::distributed_tracer::finish_span(), kcenon::monitoring::distributed_tracer::inject_context(), simulate_distributed_system(), kcenon::monitoring::distributed_tracer::start_child_span(), kcenon::monitoring::distributed_tracer::start_span(), and kcenon::monitoring::distributed_tracer::start_span_from_context().

Here is the call graph for this function:

simulate_distributed_system()

void simulate_distributed_system

(

)

Examples

distributed_tracing_example.cpp.

Definition at line 161 of file distributed_tracing_example.cpp.

                                   {
    distributed_tracer tracer;
 
    // Create services
    WebService frontend(tracer, "frontend");
    WebService backend(tracer, "backend");
    WebService database_service(tracer, "database_service");
 
    std::cout << "\n=== Simulating distributed request flow ===" << std::endl;
 
    // Simulate incoming request to frontend
    std::map<std::string, std::string> initial_headers;
    initial_headers["user-agent"] = "example-client";
 
    // Process request through frontend
    frontend.handle_request("req-001", initial_headers);
 
    std::cout << "\n=== Simulating request with existing trace ===" << std::endl;
 
    // Simulate request with existing trace context (e.g., from another service)
    std::map<std::string, std::string> traced_headers;
    traced_headers["traceparent"] = "00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01";
    traced_headers["baggage-user-id"] = "user456";
 
    backend.handle_request("req-002", traced_headers);
}

References WebService::handle_request().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: