Ensure log levels are configurable and improve logging documentation

Author: jensenbox

docs/plan.md

@@ -7,7 +7,7 @@ Tasks:
 - [x] Update the README to include a section on how to convert from pre-commit to rustyhook
 - [x] Remove the duplicate code in the github actions by consolidating the build steps and deployment steps into a single workflow (the ones that relate to publishing that is)
 - [x] enable logging to a file or other outputs other than just stdout
-- [ ] ensure logging levels are configurable and appropriate for all execution steps
+- [x] ensure logging levels are configurable and appropriate for all execution steps
 - [ ] enable using rustyhook in this repository as for pre-commit replacement and configure for a rust project
 - [ ] replace the use of pip with uv - potentially link to the source code so as to get the benefit without needing a local binary
 - [ ] emulate all known pre-commit hooks for use with native execution - all known hooks at https://github.com/pre-commit/pre-commit-hooks

src/logging.rs

@@ -2,11 +2,67 @@
 //!
 //! This module provides logging functionality for RustyHook, including
 //! the ability to log to a file or other outputs in addition to stdout.
+//!
+//! ## Log Levels
+//!
+//! The following log levels are available, in order of increasing verbosity:
+//!
+//! - `error`: Only errors are logged
+//! - `warn`: Errors and warnings are logged
+//! - `info`: Errors, warnings, and informational messages are logged (default)
+//! - `debug`: Errors, warnings, informational messages, and debug messages are logged
+//! - `trace`: All messages are logged, including detailed tracing information
+//!
+//! The log level can be set via:
+//! - The `--log-level` command line argument
+//! - The `RUSTYHOOK_LOG_LEVEL` environment variable
+//! - The `log_level` parameter in the `init` function
+//!
+//! ## Module-Specific Log Levels
+//!
+//! You can set different log levels for different modules using the `RUSTYHOOK_LOG_MODULES` 
+//! environment variable. The format is a comma-separated list of `module=level` pairs.
+//!
+//! For example:
+//!
+//! ```
+//! # Set the default log level to info
+//! export RUSTYHOOK_LOG_LEVEL=info
+//!
+//! # Set module-specific log levels
+//! export RUSTYHOOK_LOG_MODULES=rustyhook::runner=debug,rustyhook::hooks=trace
+//! ```
+//!
+//! This will set the log level for the `rustyhook::runner` module to `debug` and the
+//! log level for the `rustyhook::hooks` module to `trace`, while keeping the default
+//! log level for all other modules at `info`.
 
 use std::fs::File;
 use std::io::Write;
 use std::path::PathBuf;
-use env_logger::{Builder, Env};
+use env_logger::Builder;
+use log::LevelFilter;
+
+/// Parse a log level string into a LevelFilter
+///
+/// # Arguments
+///
+/// * `level` - The log level string to parse
+///
+/// # Returns
+///
+/// * `Result<LevelFilter, String>` - The parsed log level or an error message
+pub fn parse_log_level(level: &str) -> Result<LevelFilter, String> {
+    match level.to_lowercase().as_str() {
+        "error" => Ok(LevelFilter::Error),
+        "warn" => Ok(LevelFilter::Warn),
+        "info" => Ok(LevelFilter::Info),
+        "debug" => Ok(LevelFilter::Debug),
+        "trace" => Ok(LevelFilter::Trace),
+        "off" => Ok(LevelFilter::Off),
+        _ => Err(format!("Invalid log level: {}. Valid levels are: error, warn, info, debug, trace, off", level))
+    }
+}
 
 /// Initialize the logger with the specified configuration
 ///
@@ -15,15 +71,50 @@ use env_logger::{Builder, Env};
 /// * `log_file` - Optional path to a log file. If provided, logs will be written to this file
 ///                in addition to stdout.
 /// * `log_level` - The log level to use. If not provided, defaults to "info".
+///                 Valid values are: error, warn, info, debug, trace, off
 ///
 /// # Returns
 ///
 /// * `Result<(), String>` - Ok if the logger was initialized successfully, Err otherwise
+///
+/// # Examples
+///
+/// ```
+/// use rustyhook::logging;
+/// use std::path::PathBuf;
+///
+/// // Initialize with default log level (info)
+/// logging::init(None, None).unwrap();
+///
+/// // Initialize with debug log level
+/// logging::init(None, Some("debug")).unwrap();
+///
+/// // Initialize with log file
+/// logging::init(Some(PathBuf::from("rustyhook.log")), Some("info")).unwrap();
+/// ```
 pub fn init(log_file: Option<PathBuf>, log_level: Option<&str>) -> Result<(), String> {
-    let env = Env::default()
-        .filter_or("RUSTYHOOK_LOG_LEVEL", log_level.unwrap_or("info"));
+    // Get the log level from the parameter or environment variable
+    let level_str = match log_level {
+        Some(level) => level.to_string(),
+        None => std::env::var("RUSTYHOOK_LOG_LEVEL").unwrap_or_else(|_| "info".to_string())
+    };
+
+    // Check for module-specific log levels in the environment
+    let module_filter = std::env::var("RUSTYHOOK_LOG_MODULES").ok();
 
-    let mut builder = Builder::from_env(env);
+    // Parse and validate the log level
+    let level_filter = parse_log_level(&level_str)?;
+
+    // Create a builder with the validated log level
+    let mut builder = Builder::new();
+
+    // Apply module-specific log levels if provided
+    if let Some(filter) = module_filter {
+        builder.parse_filters(&filter);
+    } else {
+        // Otherwise, apply the global log level
+        builder.filter_level(level_filter);
+    }
 
     // Set the default format
     builder.format(|buf, record| {

tests/precommit_config_tests.rs

@@ -10,7 +10,7 @@ fn test_find_precommit_config() {
     // The test should find the .pre-commit-config.yaml file in the project root
     let result = find_precommit_config();
     assert!(result.is_ok());
-    
+
     let config_path = result.unwrap();
     assert!(config_path.exists());
     assert_eq!(config_path.file_name().unwrap(), ".pre-commit-config.yaml");
@@ -20,62 +20,62 @@ fn test_find_precommit_config() {
 fn test_convert_to_rustyhook_config() {
     // Find the pre-commit config
     let precommit_config_path = find_precommit_config().unwrap();
-    
+
     // Read the pre-commit config
     let precommit_config_str = fs::read_to_string(&precommit_config_path).unwrap();
-    
+
     // Convert to RustyHook config
     let rustyhook_config = convert_to_rustyhook_config(&precommit_config_str);
-    
+
     // Check that the conversion was successful
     assert_eq!(rustyhook_config.default_stages, vec!["commit".to_string(), "push".to_string()]);
     assert_eq!(rustyhook_config.fail_fast, true);
-    
+
     // Check that all repositories were converted
     assert!(rustyhook_config.repos.len() >= 5); // We have 5 repos in our test config
-    
+
     // Check that the pre-commit-hooks repo was converted correctly
     let precommit_hooks_repo = rustyhook_config.repos.iter()
         .find(|repo| repo.repo == "https://github.com/pre-commit/pre-commit-hooks")
         .expect("pre-commit-hooks repo not found");
-    
+
     assert_eq!(precommit_hooks_repo.hooks.len(), 4); // We have 4 hooks in this repo
-    
+
     // Check that the trailing-whitespace hook was converted correctly
     let trailing_whitespace_hook = precommit_hooks_repo.hooks.iter()
         .find(|hook| hook.id == "trailing-whitespace")
         .expect("trailing-whitespace hook not found");
-    
+
     assert_eq!(trailing_whitespace_hook.name, "Trim Trailing Whitespace");
     assert_eq!(trailing_whitespace_hook.stages, vec!["commit".to_string()]);
-    
+
     // Check that the Rust repo was converted correctly
     let rust_repo = rustyhook_config.repos.iter()
         .find(|repo| repo.repo == "https://github.com/doublify/pre-commit-rust")
         .expect("Rust repo not found");
-    
+
     assert_eq!(rust_repo.hooks.len(), 2); // We have 2 hooks in this repo
-    
+
     // Check that the fmt hook was converted correctly
     let fmt_hook = rust_repo.hooks.iter()
         .find(|hook| hook.id == "fmt")
         .expect("fmt hook not found");
-    
+
     assert_eq!(fmt_hook.name, "Rust Formatter");
     assert_eq!(fmt_hook.language, "rust");
-    
+
     // Check that the local repo was converted correctly
     let local_repo = rustyhook_config.repos.iter()
         .find(|repo| repo.repo == "local")
         .expect("local repo not found");
-    
+
     assert_eq!(local_repo.hooks.len(), 2); // We have 2 hooks in this repo
-    
+
     // Check that the custom-python-script hook was converted correctly
     let custom_python_hook = local_repo.hooks.iter()
         .find(|hook| hook.id == "custom-python-script")
         .expect("custom-python-script hook not found");
-    
+
     assert_eq!(custom_python_hook.name, "Custom Python Script");
     assert_eq!(custom_python_hook.language, "python");
     assert!(custom_python_hook.additional_dependencies.contains(&"requests==2.28.2".to_string()));
@@ -86,26 +86,26 @@ fn test_convert_from_precommit() {
     // Create a temporary directory for the test
     let temp_dir = tempfile::tempdir().unwrap();
     let original_dir = env::current_dir().unwrap();
-    
+
     // Copy the .pre-commit-config.yaml file to the temporary directory
     let precommit_config_path = original_dir.join(".pre-commit-config.yaml");
     let temp_precommit_config_path = temp_dir.path().join(".pre-commit-config.yaml");
     fs::copy(&precommit_config_path, &temp_precommit_config_path).unwrap();
-    
+
     // Change to the temporary directory
     env::set_current_dir(&temp_dir).unwrap();
-    
+
     // Convert from pre-commit config
-    let result = rustyhook::config::convert_from_precommit::<&str>(None, None);
+    let result = rustyhook::config::convert_from_precommit::<&str>(None, None, false);
     assert!(result.is_ok());
-    
+
     // Check that the .rustyhook/config.yaml file was created
     let rustyhook_config_path = temp_dir.path().join(".rustyhook").join("config.yaml");
     assert!(rustyhook_config_path.exists());
-    
+
     // Read the RustyHook config
     let rustyhook_config_str = fs::read_to_string(&rustyhook_config_path).unwrap();
-    
+
     // Check that the conversion was successful
     assert!(rustyhook_config_str.contains("default_stages: [commit, push]"));
     assert!(rustyhook_config_str.contains("fail_fast: true"));
@@ -115,7 +115,7 @@ fn test_convert_from_precommit() {
     assert!(rustyhook_config_str.contains("id: fmt"));
     assert!(rustyhook_config_str.contains("repo: local"));
     assert!(rustyhook_config_str.contains("id: custom-python-script"));
-    
+
     // Change back to the original directory
     env::set_current_dir(original_dir).unwrap();
-}
+}