use tracing::{span, Level, info};
 
fn basic_span_example() {
    let span = span!(Level::INFO, "database_query");
    
    // enter() returns an Entered guard
    let _enter = span.enter();
    
    // While _enter exists, "database_query" is the active span
    info!("executing query");  // This event is under "database_query"
    
    // When _enter goes out of scope, span exits automatically
}

use tracing::{span, Level, info, debug};
 
fn raii_pattern() {
    let outer = span!(Level::INFO, "outer");
    let _outer = outer.enter();
    
    debug!("inside outer span");
    
    {
        let inner = span!(Level::INFO, "inner");
        let _inner = inner.enter();
        
        debug!("inside inner span");  // Parented by "inner"
        
        // _inner dropped here, exits "inner"
    }
    
    debug!("back to outer span");  // Parented by "outer"
    
    // _outer dropped here, exits "outer"
}

use tracing::{span, Level, info};
 
fn premature_drop_example() {
    let span = span!(Level::INFO, "operation");
    
    info!("before entering span");  // Root context
    
    let _enter = span.enter();
    info!("inside span");  // Under "operation"
    
    // Explicitly dropping the guard
    drop(_enter);
    
    info!("after dropping guard");  // Back to root context
    // This event is NOT under "operation" span
    
    // Even though we're still in the same code block,
    // the span is no longer active
}

use tracing::{span, Level, info, debug};
 
fn accidental_drop_patterns() {
    let span = span!(Level::INFO, "my_span");
    
    // Pattern 1: Using the guard variable in a way that drops it
    let _enter = span.enter();
    // Some code that unintentionally moves or drops _enter...
    drop(_enter);  // Now "my_span" is exited
    
    debug!("this is not under my_span anymore");
    
    // Pattern 2: Semicolon expression ending
    let span2 = span!(Level::INFO, "another_span");
    {
        let _enter = span2.enter();
        // Guard dropped at end of this block
    }
    debug!("not under another_span");
    
    // Pattern 3: Reusing variable name (shadows and drops previous)
    let span3 = span!(Level::INFO, "third_span");
    let _enter = span3.enter();
    debug!("under third_span");
    
    let _enter = span!(Level::INFO, "fourth_span").enter();  // Drops previous _enter
    debug!("now under fourth_span, third_span is exited");
}

use tracing::{span, Level, info, debug};
use tracing_subscriber::fmt::format::FmtSpan;
 
fn visualize_span_context() {
    // Set up subscriber to show span context
    tracing_subscriber::fmt()
        .with_span_events(FmtSpan::ACTIVE)
        .with_target(false)
        .init();
    
    let span = span!(Level::INFO, "request_processing");
    let _enter = span.enter();
    
    info!("starting request");  // Under request_processing
    
    {
        let nested = span!(Level::INFO, "validation");
        let _nested = nested.enter();
        
        debug!("validating input");  // Under validation, which is under request_processing
    }
    
    info!("validation complete");  // Under request_processing
    
    drop(_enter);  // Exit request_processing early
    
    info!("sending response");  // Root context
}

use tracing::{span, Level, info, debug};
 
fn in_scope_example() {
    let span = span!(Level::INFO, "processing");
    
    // in_scope takes a closure, ensuring the span is active only for that scope
    span.in_scope(|| {
        debug!("inside in_scope");
        info!("processing data");
    });
    
    // Span automatically exited after closure completes
    debug!("outside span");  // Not under processing
    
    // Unlike enter(), you can't accidentally drop the guard early
    // The span is active for exactly the closure's duration
}

use tracing::{span, Level, info, error, warn};
use std::time::Instant;
 
fn observability_impact() {
    let span = span!(Level::INFO, "api_handler", endpoint = "/users");
    let _enter = span.enter();
    
    let start = Instant::now();
    info!("request received");
    
    // Simulate some work
    std::thread::sleep(std::time::Duration::from_millis(10));
    
    // If we drop here accidentally...
    drop(_enter);
    
    // These events won't be correlated with the api_handler span:
    let duration = start.elapsed();
    info!(?duration, "request processed");  // Lost span context!
    error!("database timeout");               // Lost span context!
    
    // In production, this breaks distributed tracing:
    // - Can't filter by endpoint
    // - Can't see request duration in span
    // - Logs aren't correlated
}

use tracing::{span, Level, info, debug};
 
fn nested_span_stack() {
    let outer = span!(Level::INFO, "outer");
    let middle = span!(Level::INFO, "middle");
    let inner = span!(Level::INFO, "inner");
    
    let _outer = outer.enter();
    debug!("in outer");
    
    let _middle = middle.enter();
    debug!("in middle");  // parent: outer -> middle
    
    let _inner = inner.enter();
    debug!("in inner");  // parent: outer -> middle -> inner
    
    // Dropping middle guard
    drop(_middle);
    
    // Now we're back to outer, but _inner still references "inner" span
    // The thread's active span is "outer" again
    debug!("where are we?");  // parent: outer (middle is exited)
    
    // The inner guard's span context is still "inner",
    // but it's now parented by "outer" since "middle" was removed from stack
}
 
fn proper_nested_exit() {
    let outer = span!(Level::INFO, "outer");
    let middle = span!(Level::INFO, "middle");
    let inner = span!(Level::INFO, "inner");
    
    let _outer = outer.enter();
    {
        let _middle = middle.enter();
        {
            let _inner = inner.enter();
            debug!("in inner");
        }  // _inner dropped
        debug!("back to middle");
    }  // _middle dropped
    debug!("back to outer");
}

use tracing::{span, Level, info};
use std::thread;
 
fn thread_safety() {
    let span = span!(Level::INFO, "main_operation");
    
    // Each thread has its own span context stack
    thread::spawn(move || {
        let _enter = span.enter();
        info!("in spawned thread");  // Under main_operation in this thread
    });
    
    // Main thread's span context is separate
    info!("in main thread");  // Not under main_operation
    
    // The Entered guard only affects the thread it's created in
}

use tracing::{span, Level, info};
 
fn enter_vs_clone() {
    let span = span!(Level::INFO, "operation");
    
    // Clone creates a new handle to the same span
    let span_clone = span.clone();
    
    // But enter() must be called to make it active
    let _enter1 = span.enter();
    info!("under span");  // Active
    
    let _enter2 = span_clone.enter();
    // Both _enter1 and _enter2 refer to the same span
    // But now we've entered it twice on this thread's stack
    
    info!("still under span");
    
    drop(_enter1);  // One level of the span exited
    info!("still under span (from _enter2)");
    
    drop(_enter2);  // Span fully exited
    info!("outside span");
}

use tracing::{span, Level, info, debug};
 
fn best_practices() {
    // GOOD: Underscore prefix prevents unused variable warnings
    // while keeping the guard alive for the scope
    let span = span!(Level::INFO, "good_example");
    let _guard = span.enter();  // _ prefix is idiomatic
    
    debug!("this is under the span");
    // _guard kept alive until end of scope
    
    // GOOD: Explicit minimal scope
    {
        let span = span!(Level::INFO, "minimal_scope");
        let _enter = span.enter();
        debug!("scoped operation");
    }
    
    // GOOD: Using in_scope for explicit boundaries
    let span = span!(Level::INFO, "explicit_scope");
    span.in_scope(|| {
        debug!("explicitly scoped");
    });
    
    // AVOID: Meaningful variable names that might be accidentally used
    // let enter = span.enter();  // Could be accidentally dropped
    // some_function(enter);  // Oops, moved and dropped
}
 
// GOOD: Structured async-aware pattern with explicit scope
fn structured_pattern() {
    let span = span!(Level::INFO, "request");
    
    // All operations that should be under span
    span.in_scope(|| {
        process_request();
    });
    
    // Clear separation between span-active and post-span code
    cleanup();
}
 
fn process_request() {
    info!("processing");
}
 
fn cleanup() {
    info!("cleanup");  // Not under request span
}

use tracing::{span, Level, info, debug};
use tracing_subscriber::layer::SubscriberExt;
use tracing_subscriber::Layer;
 
// Custom layer to track span lifecycle
struct SpanTracker;
 
impl<S: tracing::Subscriber> Layer<S> for SpanTracker {
    fn on_enter(&self, attrs: &tracing::span::Attributes<'_>, _ctx: tracing_subscriber::layer::Context<'_, S>) {
        eprintln!("[ENTER] {}", attrs.metadata().name());
    }
    
    fn on_exit(&self, id: &tracing::Id, _ctx: tracing_subscriber::layer::Context<'_, S>) {
        eprintln!("[EXIT] span {:?}", id);
    }
}
 
fn detecting_drops() {
    tracing_subscriber::registry()
        .with(SpanTracker)
        .with(tracing_subscriber::fmt::layer())
        .init();
    
    let span = span!(Level::INFO, "my_span");
    let _enter = span.enter();
    // Output: [ENTER] my_span
    
    debug!("inside span");
    
    // Early!
    drop(_enter);
    // Output: [EXIT] span ...
    
    // Now events are outside span
    info!("outside span context");
}