Collaboration diagram for WebService:

Public Member Functions
	WebService (distributed_tracer &tracer, const std::string &name)

void	handle_request (const std::string &request_id, const std::map< std::string, std::string > &headers)

Private Member Functions
void	process_business_logic (std::shared_ptr< trace_span > parent_span)

void	query_database (std::shared_ptr< trace_span > parent_span)

void	call_downstream_service (std::shared_ptr< trace_span > parent_span)

Private Attributes
distributed_tracer &	tracer_

std::string	service_name_

Detailed Description

Examples: distributed_tracing_example.cpp.

Definition at line 29 of file distributed_tracing_example.cpp.

Constructor & Destructor Documentation

◆ WebService()

WebService::WebService	(	distributed_tracer &	tracer,
		const std::string &	name )

inline

Examples: distributed_tracing_example.cpp.

Definition at line 35 of file distributed_tracing_example.cpp.

36 : tracer_(tracer), service_name_(name) {}

WebService::service_name_

std::string service_name_

Definition distributed_tracing_example.cpp:32

WebService::tracer_

distributed_tracer & tracer_

Definition distributed_tracing_example.cpp:31

Member Function Documentation

◆ call_downstream_service()

void WebService::call_downstream_service ( std::shared_ptr< trace_span > parent_span )

inlineprivate

Examples: distributed_tracing_example.cpp.

Definition at line 134 of file distributed_tracing_example.cpp.

                                                                        {
        // Create a child span for downstream call
        auto span_result = tracer_.start_child_span(*parent_span, "downstream_call");
        if (!span_result.is_ok()) return;
 
        auto span = span_result.value();
        span->tags["peer.service"] = "downstream_service";
        span->tags["span.kind"] = "client";
 
        // Extract context to propagate to downstream service
        auto context = tracer_.extract_context(*span);
 
        // Prepare headers for downstream call
        std::map<std::string, std::string> headers;
        tracer_.inject_context(context, headers);
 
        std::cout << "[" << service_name_ << "] Calling downstream service..." << std::endl;
        std::cout << "  Propagating trace: " << context.trace_id << std::endl;
 
        // Simulate HTTP call with headers
        std::this_thread::sleep_for(30ms);
 
        tracer_.finish_span(span);
    }

References kcenon::monitoring::distributed_tracer::extract_context(), kcenon::monitoring::distributed_tracer::finish_span(), kcenon::monitoring::distributed_tracer::inject_context(), service_name_, kcenon::monitoring::distributed_tracer::start_child_span(), and tracer_.

Referenced by handle_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ handle_request()

void WebService::handle_request	(	const std::string &	request_id,
		const std::map< std::string, std::string > &	headers )

inline

Examples: distributed_tracing_example.cpp.

Definition at line 39 of file distributed_tracing_example.cpp.

                                                                    {
        std::cout << "[" << service_name_ << "] Processing request: " << request_id << std::endl;
 
        // Extract trace context from incoming headers
        auto context_result = tracer_.extract_context_from_carrier(headers);
 
        std::shared_ptr<trace_span> span;
 
        if (context_result.is_ok()) {
            // Continue existing trace
            auto span_result = tracer_.start_span_from_context(
                context_result.value(),
                service_name_ + "_handler"
            );
            if (span_result.is_ok()) {
                span = span_result.value();
                std::cout << "[" << service_name_ << "] Continuing trace: "
                         << context_result.value().trace_id << std::endl;
            }
        } else {
            // Start new trace
            auto span_result = tracer_.start_span(
                service_name_ + "_handler",
                service_name_
            );
            if (span_result.is_ok()) {
                span = span_result.value();
                std::cout << "[" << service_name_ << "] Started new trace: "
                         << span->trace_id << std::endl;
            }
        }
 
        if (span) {
            // Add tags to the span
            span->tags["service"] = service_name_;
            span->tags["request_id"] = request_id;
            span->tags["http.method"] = "GET";
            span->tags["http.url"] = "/api/process";
            span->tags["user.id"] = "user123";
 
            // Simulate processing
            process_business_logic(span);
 
            // Simulate calling downstream service
            call_downstream_service(span);
 
            // Mark span as successful
            span->status = trace_span::status_code::ok;
 
            // Finish the span
            tracer_.finish_span(span);
 
            std::cout << "[" << service_name_ << "] Span completed: "
                     << span->span_id << std::endl;
        }
    }

References call_downstream_service(), kcenon::monitoring::distributed_tracer::extract_context_from_carrier(), kcenon::monitoring::distributed_tracer::finish_span(), process_business_logic(), service_name_, kcenon::monitoring::distributed_tracer::start_span(), kcenon::monitoring::distributed_tracer::start_span_from_context(), and tracer_.

Referenced by simulate_distributed_system().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ process_business_logic()

void WebService::process_business_logic ( std::shared_ptr< trace_span > parent_span )

inlineprivate

Examples: distributed_tracing_example.cpp.

Definition at line 98 of file distributed_tracing_example.cpp.

                                                                       {
        // Create a child span for business logic
        auto span_result = tracer_.start_child_span(*parent_span, "business_logic");
        if (!span_result.is_ok()) return;
 
        auto span = span_result.value();
        span->tags["operation"] = "data_processing";
 
        std::cout << "[" << service_name_ << "] Processing business logic..." << std::endl;
 
        // Simulate some work
        std::this_thread::sleep_for(50ms);
 
        // Simulate database query
        query_database(span);
 
        tracer_.finish_span(span);
    }

References kcenon::monitoring::distributed_tracer::finish_span(), query_database(), service_name_, kcenon::monitoring::distributed_tracer::start_child_span(), and tracer_.

Referenced by handle_request().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ query_database()

void WebService::query_database ( std::shared_ptr< trace_span > parent_span )

inlineprivate

Examples: distributed_tracing_example.cpp.

Definition at line 117 of file distributed_tracing_example.cpp.

                                                               {
        // Create a child span for database query
        auto span_result = tracer_.start_child_span(*parent_span, "database_query");
        if (!span_result.is_ok()) return;
 
        auto span = span_result.value();
        span->tags["db.type"] = "postgresql";
        span->tags["db.statement"] = "SELECT * FROM users WHERE id = ?";
 
        std::cout << "[" << service_name_ << "] Querying database..." << std::endl;
 
        // Simulate database query
        std::this_thread::sleep_for(20ms);
 
        tracer_.finish_span(span);
    }