use tracing::{info, instrument, span, Level};
use tracing::Instrument;
use std::time::Duration;
 
#[tokio::main]
async fn main() {
    // Initialize a subscriber to see output
    tracing_subscriber::fmt().init();
    
    // Create a span manually
    let span = span!(Level::INFO, "request_processing");
    
    // instrument() wraps the future with the span
    async fn process_request() {
        info!("Processing request");
        tokio::time::sleep(Duration::from_millis(10)).await;
        info!("Request complete");
    }
    
    // Without instrument: events have no parent span
    process_request().await;
    
    // With instrument: events are children of the span
    process_request().instrument(span).await;
}

use tracing::{info, span, Level, Instrument};
use std::time::Duration;
 
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt().init();
    
    // instrument() is a method from the Instrument trait
    // It returns an Instrumented<F> wrapper
    
    let span = span!(Level::INFO, "operation");
    
    async fn my_async_work() -> i32 {
        info!("Working...");
        tokio::time::sleep(Duration::from_millis(10)).await;
        info!("Done working");
        42
    }
    
    // Method 1: Call .instrument() on the future
    let result = my_async_work().instrument(span).await;
    println!("Result: {}", result);
    
    // Method 2: Use instrument() as a free function
    let span = span!(Level::INFO, "another_operation");
    let result = tracing::instrument(my_async_work(), span).await;
    println!("Result: {}", result);
    
    // The Instrumented wrapper:
    // - Enters the span before each poll
    // - Exits the span after each poll
    // - Ensures proper context propagation across await points
}

use tracing::{info, span, Level, Instrument};
use std::time::Duration;
 
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt()
        .with_max_level(Level::DEBUG)
        .init();
    
    let span = span!(Level::INFO, "parent_span");
    
    async fn multi_stage_work() {
        info!("Stage 1: Starting");
        
        // First await point
        tokio::time::sleep(Duration::from_millis(5)).await;
        
        // After first await, span is re-entered automatically
        info!("Stage 2: After first sleep");
        
        // Second await point
        tokio::time::sleep(Duration::from_millis(5)).await;
        
        // After second await, span is still active
        info!("Stage 3: Complete");
    }
    
    // Without instrument: each event has no parent
    println!("Without instrument:");
    multi_stage_work().await;
    
    // With instrument: all events are children of parent_span
    println!("\nWith instrument:");
    multi_stage_work().instrument(span).await;
}

use tracing::{info, instrument, Level};
use std::time::Duration;
 
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt().init();
    
    // The #[instrument] attribute automatically creates and attaches a span
    process_order(123, "premium").await;
}
 
// #[instrument] creates a span named "process_order"
// It automatically logs function arguments
#[instrument]
async fn process_order(order_id: u32, tier: &str) {
    info!("Validating order");
    tokio::time::sleep(Duration::from_millis(10)).await;
    
    info!("Processing payment");
    tokio::time::sleep(Duration::from_millis(10)).await;
    
    info!("Order complete");
}
 
// Can customize the span name and level
#[instrument(name = "user_authentication", level = Level::DEBUG)]
async fn authenticate_user(username: &str) -> bool {
    info!("Checking credentials");
    tokio::time::sleep(Duration::from_millis(5)).await;
    username == "admin"
}
 
// Skip certain arguments from the span
#[instrument(skip(password))]
async fn login(username: &str, password: &str) -> bool {
    info!("Attempting login");
    authenticate_user(username).await
}
 
// Add custom fields to the span
#[instrument(fields(category = "api", version = "1.0"))]
async fn api_call(endpoint: &str) {
    info!("Calling endpoint: {}", endpoint);
}

use tracing::{info, instrument, span, Level, Instrument};
use std::time::Duration;
 
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt()
        .with_target(false)
        .init();
    
    // Parent span
    let parent = span!(Level::INFO, "http_request", method = "GET", path = "/api/users");
    
    async fn handle_request() {
        info!("Starting request handling");
        fetch_from_database().await;
        call_external_service().await;
        info!("Request complete");
    }
    
    async fn fetch_from_database() {
        // This creates a child span of the current span
        let span = span!(Level::INFO, "database_query", table = "users");
        async {
            info!("Executing query");
            tokio::time::sleep(Duration::from_millis(10)).await;
            info!("Query complete");
        }
        .instrument(span)
        .await;
    }
    
    async fn call_external_service() {
        let span = span!(Level::INFO, "external_call", service = "payment");
        async {
            info!("Calling external service");
            tokio::time::sleep(Duration::from_millis(10)).await;
            info!("External call complete");
        }
        .instrument(span)
        .await;
    }
    
    handle_request().instrument(parent).await;
}

use tracing::{info, span, Level, Instrument};
use tracing_opentelemetry::OpenTelemetrySpanExt;
use opentelemetry::trace::{TraceContextExt, SpanKind};
 
#[tokio::main]
async fn main() {
    // Set up OpenTelemetry exporter for distributed tracing
    // (simplified - in production you'd configure a real exporter)
    
    // When a request comes in with trace context headers:
    // - traceparent: 00-4bf92f3577b34da6a3ce929d0e0e4736-00f067aa0ba902b7-01
    // - tracestate: some=value
    
    // Extract the context and create a parent span
    async fn handle_incoming_request(traceparent: Option<&str>) {
        let span = if let Some(parent) = traceparent {
            // Parse the traceparent and create a span with the extracted context
            span!(Level::INFO, "incoming_request")
        } else {
            // Start a new trace
            span!(Level::INFO, "incoming_request")
        };
        
        async {
            info!("Processing incoming request");
            call_downstream_service().await;
            info!("Request processed");
        }
        .instrument(span)
        .await;
    }
    
    async fn call_downstream_service() {
        let span = span!(Level::INFO, "downstream_call", service = "inventory");
        async {
            info!("Calling inventory service");
            
            // In a real implementation, you would:
            // 1. Get the current span context
            // 2. Inject it into HTTP headers
            // 3. The downstream service extracts and continues the trace
            
            tokio::time::sleep(std::time::Duration::from_millis(10)).await;
            info!("Downstream call complete");
        }
        .instrument(span)
        .await;
    }
    
    handle_incoming_request(None).await;
}

use tracing::{info, span, Level, Instrument};
use std::time::Duration;
 
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt()
        .with_max_level(Level::DEBUG)
        .init();
    
    let parent_span = span!(Level::INFO, "parent");
    
    async fn demonstrate_context() {
        // The current span is available via span!() and info!() etc.
        // It's stored in thread-local storage during the poll
        
        // Create a child span - it automatically becomes a child
        let child_span = span!(Level::INFO, "child");
        
        async {
            info!("In child span");
            
            // Grandchild is automatically a child of child
            let grandchild = span!(Level::DEBUG, "grandchild");
            async {
                info!("In grandchild span");
            }
            .instrument(grandchild)
            .await;
            
            info!("Back in child span");
        }
        .instrument(child_span)
        .await;
        
        info!("Back in parent span");
    }
    
    // The instrument wrapper:
    // 1. Before poll: enters the span (sets current span in thread-local)
    // 2. During poll: all span!() and info!() use the current span
    // 3. After poll: exits the span (restores parent span)
    
    demonstrate_context().instrument(parent_span).await;
}

use tracing::{info, span, Level, Instrument};
use tokio::task::JoinHandle;
use std::time::Duration;
 
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt().init();
    
    let parent_span = span!(Level::INFO, "main_operation");
    
    // Without instrument: spawned task loses context
    let handle1 = tokio::spawn(async {
        info!("Task without instrument - no parent span!");
    });
    
    // With instrument: spawned task carries span context
    let child_span = span!(Level::INFO, "background_task", task_id = 1);
    let handle2: JoinHandle<()> = tokio::spawn(
        async {
            info!("Task with instrument - has parent span");
            
            // Nested spans work too
            let inner = span!(Level::DEBUG, "inner_work");
            async {
                info!("Inner work in spawned task");
            }
            .instrument(inner)
            .await;
        }
        .instrument(child_span)
    );
    
    // Alternative: instrument within the spawn
    let handle3 = tokio::spawn(
        async {
            info!("Another instrumented task");
        }
        .instrument(span!(Level::INFO, "task_3"))
    );
    
    // Wait for all tasks
    handle1.await.unwrap();
    handle2.await.unwrap();
    handle3.await.unwrap();
    
    // IMPORTANT: instrument() must be called INSIDE the spawn
    // If called outside, the span may be entered before spawning
    // and the context might not propagate correctly
}

use tracing::{info, instrument, span, Level, Instrument};
use std::time::Duration;
use std::sync::Arc;
use tokio::sync::Mutex;
 
// Simulated request context
struct RequestContext {
    request_id: String,
    user_id: Option<String>,
}
 
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt()
        .with_max_level(Level::DEBUG)
        .init();
    
    // Each request gets its own span with request-scoped data
    handle_request("req-123", Some("user-456")).await;
    handle_request("req-789", None).await;
}
 
#[instrument(
    name = "http_request",
    skip(request_id, user_id),
    fields(
        request_id = %request_id,
        user_id = ?user_id
    )
)]
async fn handle_request(request_id: &str, user_id: Option<&str>) {
    info!("Handling request");
    
    // All child spans and events have the request_id field
    authenticate(user_id).await;
    process_data().await;
    
    info!("Request complete");
}
 
#[instrument(skip(user_id))]
async fn authenticate(user_id: Option<&str>) {
    match user_id {
        Some(id) => {
            info!(user_id = %id, "User authenticated");
        }
        None => {
            info!("Anonymous request");
        }
    }
    tokio::time::sleep(Duration::from_millis(5)).await;
}
 
#[instrument]
async fn process_data() {
    info!("Processing data");
    
    // Simulate parallel work with shared span context
    let task1 = tokio::spawn(
        async {
            info!("Parallel task 1");
        }
        .instrument(span!(Level::DEBUG, "parallel_task_1"))
    );
    
    let task2 = tokio::spawn(
        async {
            info!("Parallel task 2");
        }
        .instrument(span!(Level::DEBUG, "parallel_task_2"))
    );
    
    task1.await.unwrap();
    task2.await.unwrap();
    
    info!("Data processing complete");
}

use tracing::{info, span, Level, Instrument};
use tracing_opentelemetry::OpenTelemetrySpanExt;
 
#[tokio::main]
async fn main() {
    // Set up with OpenTelemetry for trace/span ID access
    let tracer = opentelemetry_otlp::new_pipeline()
        .tracing()
        .with_exporter(opentelemetry_otlp::new_exporter().tonic())
        .install_simple()
        .unwrap();
    
    let telemetry = tracing_opentelemetry::layer().with_tracer(tracer);
    tracing_subscriber::registry()
        .with(telemetry)
        .with(tracing_subscriber::fmt::layer())
        .init();
    
    let root_span = span!(Level::INFO, "root_operation");
    
    async fn work_with_trace_ids() {
        // Access the current span
        let current_span = tracing::Span::current();
        
        // Get trace and span IDs (requires OpenTelemetry integration)
        let context = current_span.context();
        let trace_id = context.span().span_context().trace_id();
        let span_id = context.span().span_context().span_id();
        
        info!(
            trace_id = %trace_id,
            span_id = %span_id,
            "Working with trace context"
        );
        
        // These IDs can be logged, sent to downstream services, etc.
        // for distributed trace correlation
    }
    
    work_with_trace_ids().instrument(root_span).await;
    
    // Flush telemetry
    opentelemetry::global::shutdown_tracer_provider();
}

use tracing::{info, span, Level, Instrument};
use std::time::Duration;
 
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt().init();
    
    // AUTOMATIC: Using instrument()
    let span_auto = span!(Level::INFO, "automatic_span");
    async fn automatic_work() {
        info!("This is inside the span");
        tokio::time::sleep(Duration::from_millis(10)).await;
        info!("Still inside the span after await");
    }
    automatic_work().instrument(span_auto).await;
    
    // MANUAL: Entering and exiting spans (error-prone)
    let span_manual = span!(Level::INFO, "manual_span");
    let _enter = span_manual.enter();  // Enter the span
    
    info!("This is inside the span");
    
    // PROBLEM: The guard (_enter) keeps the span entered
    // across the await point, which is incorrect!
    // The span stays entered even when the runtime
    // switches to another task.
    
    // This is WRONG for async code:
    // tokio::time::sleep(Duration::from_millis(10)).await;
    // The span remains entered while other tasks run!
    
    // The correct manual way is complex:
    drop(_enter);  // Exit before await
    tokio::time::sleep(Duration::from_millis(10)).await;
    let _enter = span_manual.enter();  // Re-enter after await
    
    info!("Back in span after await");
    drop(_enter);  // Exit when done
    
    // instrument() handles all of this automatically!
}

use tracing::{error, info, span, Level, Instrument};
use std::time::Duration;
 
#[tokio::main]
async fn main() {
    tracing_subscriber::fmt().init();
    
    let span = span!(Level::INFO, "operation_with_error");
    
    async fn fallible_work() -> Result<String, &'static str> {
        info!("Starting work");
        tokio::time::sleep(Duration::from_millis(5)).await;
        
        // Simulate an error
        Err("Something went wrong")
    }
    
    // The span context is preserved even through errors
    let result = fallible_work()
        .instrument(span.clone())
        .await;
    
    match result {
        Ok(value) => info!(value = %value, "Success"),
        Err(e) => error!(error = %e, "Failed"),
    }
    
    // Using #[instrument] with errors
    #[tracing::instrument]
    async fn another_fallible() -> Result<i32, String> {
        info!("Working");
        tokio::time::sleep(Duration::from_millis(5)).await;
        Err("Another error".to_string())
    }
    
    // The span records the error automatically with #[instrument(err)]
    #[tracing::instrument(err)]
    async fn with_error_recording() -> Result<i32, String> {
        info!("Working with error recording");
        tokio::time::sleep(Duration::from_millis(5)).await;
        Err("Recorded error".to_string())
    }
    
    let _ = with_error_recording().await;
}

// Entry point: create request-scoped span
#[instrument(skip(request))]
async fn handle_request(request: Request) -> Response {
    // All work is traced
    process(&request).await?;
    Ok(Response::new())
}
 
// Spawned tasks: inherit or create child spans
tokio::spawn(
    background_work()
        .instrument(span!(Level::INFO, "background"))
);
 
// External calls: create child spans for out-of-process work
#[instrument]
async fn call_service() {
    let span = span!(Level::INFO, "http_call", service = "inventory");
    async {
        // HTTP client with trace context headers
    }
    .instrument(span)
    .await;
}