[StackOverflow/rust] How should we handle centralize logging in Hexagonal Architecture? Should there be a logging service?

### ROOT CAUSE The issue arises from a misunderstanding of Hexagonal Architecture (Ports & Adapters). Centralized logging should not be handled by a service within the core domain logic. Instead, logging is an infrastructure concern that should be externalized. The core business logic should remain decoupled from logging frameworks (e.g., `log`, `slog`) to maintain testability and adherence to the architecture. Mixing logging with core business logic violates the separation of concerns principle. ### CODE FIX 1. **Define a Logging Interface (Port):** Create a trait in the core to abstract logging. 2. **Implement Adapters:** Use Rust's trait system to implement adapters for different logging libraries (e.g., `log`, `slog`). 3. **Centralize via Dependency Injection:** Inject the logging adapter into the application entry point. **Example Implementation:** ```rust // Logger trait (core/domain/logger.rs) pub trait Logger { fn log(&self, message: &str); } // Adapter for the `log` crate (infrastructure/logging/log_adapter.rs) use log::debug; pub struct LogAdapter; impl Logger for LogAdapter { fn log(&self, message: &str) { debug!("{}", message); } } // Application entry point (main.rs) mod domain; mod infrastructure; use infrastructure::LogAdapter; fn main() { // Initialize logging (e.g., env_logger) env_logger::init(); let logger = LogAdapter; // Pass logger to domain logic (via dependency injection) run_with_logger(|| { // Domain logic that uses logger logger.log("Hello from Hexagonal Architecture!"); }); } ``` **Explanation:** - The `Logger` trait abstracts logging, ensuring the core doesn't depend on specific logging libraries. - `LogAdapter` implements the trait using the `log` crate, making it framework-agnostic. - Logging is injected via dependency injection, centralizing it while keeping the core decoupled. This aligns with Hexagonal Architecture by treating logging as an external adapter.