tools-and-config

🛠️ TOOLS AND CONFIGURATION BEST PRACTICES

TL;DR: Essential tools and configuration patterns for modern Rust applications, focusing on logging, configuration management, and templating.

🔍 TOOLS & CONFIGURATION STRATEGY

graph TD
    Start["Application Setup"] --> ConfigType{"Configuration<br>Complexity?"}

    ConfigType -->|Simple| EnvVars["Environment Variables"]
    ConfigType -->|Complex| YAMLConfig["YAML Configuration"]

    EnvVars --> Logging["Logging Setup"]
    YAMLConfig --> ConfigValidation["Configuration Validation"]
    ConfigValidation --> Logging

    Logging --> StructuredLogging["Structured Logging"]
    StructuredLogging --> LogRotation["Log Rotation"]

    LogRotation --> Templating{"Template<br>Engine Needed?"}

    Templating -->|Yes| MiniJinja["MiniJinja Templates"]
    Templating -->|No| DataProcessing["Data Processing"]

    MiniJinja --> DataProcessing
    DataProcessing --> JSONPath["JSON Path Extraction"]

    JSONPath --> Monitoring["Application Monitoring"]
    Monitoring --> Production["Production Tools"]

    style Start fill:#4da6ff,stroke:#0066cc,color:white
    style YAMLConfig fill:#4dbb5f,stroke:#36873f,color:white
    style StructuredLogging fill:#ffa64d,stroke:#cc7a30,color:white
    style MiniJinja fill:#d94dbb,stroke:#a3378a,color:white

📊 LOGGING AND OBSERVABILITY

Tracing Ecosystem (Not env_logger)

• Always use tracing - modern structured logging
• Combine with tracing-subscriber for output formatting
• File rotation with tracing-appender for production
• Structured logging with spans and events

# Cargo.toml - Tracing configuration
[dependencies]
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
chrono = { version = "0.4", features = ["serde"] }

Structured Logging Setup

use tracing::{info, error, warn, debug, span, Level};
use tracing_subscriber::{
    fmt::{self, time::ChronoUtc},
    layer::SubscriberExt,
    util::SubscriberInitExt,
    EnvFilter,
    Registry,
};
use tracing_appender::{non_blocking, rolling};

pub fn init_logging(config: &LogConfig) -> Result<(), Box<dyn std::error::Error>> {
    // Create file appender with rotation
    let file_appender = rolling::daily(&config.log_dir, "app.log");
    let (file_writer, _guard) = non_blocking(file_appender);

    // Console formatting
    let console_layer = fmt::layer()
        .with_target(true)
        .with_timer(ChronoUtc::rfc_3339())
        .with_level(true)
        .with_thread_ids(true)
        .with_thread_names(true);

    // File formatting (JSON for structured logs)
    let file_layer = fmt::layer()
        .json()
        .with_timer(ChronoUtc::rfc_3339())
        .with_writer(file_writer);

    // Environment filter
    let filter = EnvFilter::try_from_default_env()
        .unwrap_or_else(|_| EnvFilter::new(&config.level));

    Registry::default()
        .with(filter)
        .with(console_layer)
        .with(file_layer)
        .init();

    Ok(())
}

// Usage in application code
#[tracing::instrument(skip(service), fields(user_id = %user_id))]
pub async fn process_user_registration(
    user_id: &str,
    service: &UserService,
) -> Result<User, ServiceError> {
    let span = span!(Level::INFO, "user_registration", user_id = %user_id);
    let _enter = span.enter();

    info!("Starting user registration process");

    let user = service.create_user(user_id).await.map_err(|e| {
        error!("Failed to create user: {}", e);
        e
    })?;

    info!(
        user_id = %user.id,
        email = %user.email,
        "User registration completed successfully"
    );

    Ok(user)
}

// Contextual logging with structured fields
pub async fn handle_payment_processing(
    order_id: &str,
    amount: f64,
    payment_method: &str,
) -> Result<PaymentResult, PaymentError> {
    let span = span!(
        Level::INFO,
        "payment_processing",
        order_id = %order_id,
        amount = %amount,
        payment_method = %payment_method
    );
    let _enter = span.enter();

    info!("Processing payment");

    match process_payment(order_id, amount, payment_method).await {
        Ok(result) => {
            info!(
                transaction_id = %result.transaction_id,
                status = %result.status,
                "Payment processed successfully"
            );
            Ok(result)
        }
        Err(e) => {
            error!(
                error = %e,
                "Payment processing failed"
            );
            Err(e)
        }
    }
}