Struct WasmStdoutAdapter 

pub struct WasmStdoutAdapter { /* private fields */ }

WASM stdout transport adapter

Implementations

impl WasmStdoutAdapter

pub fn new(formatter: Box<dyn FormatterPort>) -> Self

pub fn with_json_formatter() -> Self

pub fn with_compact_formatter() -> Self

Examples found in repository

examples/tracing_and_kv_demo.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 Tracing Integration and Structured Fields Demo");
    println!("================================================\n");

    // 0) Initialize standard Rust logging (log::*) via the singleton manager.
    // This keeps the example safe (no stack-pointer logger installation).
    let mut manager = ObservabilityManager::new(ObservabilityConfig {
        level: "debug".to_string(),
        format: "compact".to_string(),
        structured: true,
        context_enrichment: true,
        default_context: Default::default(),
    })?;
    manager.initialize()?;

    // 1. Set up tracing integration
    println!("🔧 Setting up tracing integration...");
    let tracing_subscriber = TracingIntegrationBuilder::new()
        .with_processor_chain(observability_core::domain::build_enhanced_processor_chain())
        .with_transport(Arc::new(WasmStdoutAdapter::with_compact_formatter()))
        .with_level_filter(observability_core::traits::LogLevel::Debug)
        .build()?;

    // Set as global tracing subscriber
    tracing::subscriber::set_global_default(tracing_subscriber)
        .map_err(|e| format!("Failed to set tracing subscriber: {}", e))?;

    println!("✅ Tracing integration active\n");

    // 2. Demo tracing events
    println!("📊 Testing tracing events:");
    println!("-------------------------");

    let span = span!(Level::INFO, "demo_operation", operation_id = "op-123");
    let _enter = span.enter();

    info!(target: "demo", user_id = "user-456", session = "sess-789", "Operation started");
    debug!(items = 42, size = 1024, "Processing data");

    // Nested span
    {
        let nested_span = span!(Level::DEBUG, "data_processing", batch_id = "batch-001");
        let _nested_enter = nested_span.enter();

        info!(records = 100, duration_ms = 250, "Processing batch");
        debug!(errors = 0, warnings = 2, "Validation complete");
    }

    info!(
        status = "success",
        total_time_ms = 500,
        "Operation completed"
    );

    if false {
        error!(
            error_code = 500,
            details = "Connection timeout",
            "This would be an error"
        );
    }

    println!("✅ Tracing events logged with structured fields and span context\n");

    // 3. Demo structured fields with standard log macros
    println!("📝 Testing structured fields with standard log macros:");
    println!("-----------------------------------------------------");

    // Standard log messages.
    // (KV-style structured fields are supported by the core pipeline, but we keep this example
    // syntax conservative to compile across toolchains.)
    log::info!("User login successful");
    log::debug!("Database query executed");
    log::warn!("High memory usage detected");

    println!("✅ Standard log macros processed through LogKvExtractor\n");

    // 4. Demo mixed usage
    println!("🔄 Testing mixed tracing and log usage:");
    println!("---------------------------------------");

    let mixed_span = span!(Level::INFO, "mixed_operation", request_id = "req-999");
    let _mixed_enter = mixed_span.enter();

    // Tracing event
    info!(
        endpoint = "/api/users",
        method = "GET",
        "Processing request"
    );

    // Standard log messages
    log::info!("Authentication successful");

    // Tracing debug
    debug!(cache_key = "user:123", hit = true, "Cache lookup");

    // Standard log debug
    log::debug!("Response prepared");

    info!(
        status = "success",
        response_time_ms = 89,
        "Request completed"
    );

    println!("✅ Mixed tracing and log usage working together\n");

    println!("🎉 Demo completed successfully!");
    println!("\n💡 Key Features Demonstrated:");
    println!("   ✨ Tracing events → structured logs with span context");
    println!("   🔑 log::info!(\"msg\"; \"key\" => value) → automatic kv extraction");
    println!("   🔗 Unified processing through hexagonal architecture");
    println!("   📊 Enhanced processor chain with metadata enrichment");
    println!("   🎯 Both tracing and log work together seamlessly");

    Ok(())
}

pub fn with_plain_text_formatter() -> Self

Trait Implementations

impl TransportPort for WasmStdoutAdapter

fn transport(&self, entry: &LogEntry) -> ObservabilityResult<()>

Transport a single log entry

fn transport_batch(&self, entries: &[LogEntry]) -> ObservabilityResult<()>

Transport multiple log entries (for batching)