fix

crates/config/Cargo.toml

@@ -7,11 +7,17 @@ rust-version.workspace = true
 version.workspace = true
 
 [dependencies]
-config = { workspace = true }
-const-str = { workspace = true }
+const-str = { workspace = true, optional = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 
 
 [lints]
 workspace = true
+
+[features]
+default = []
+constants = ["dep:const-str"]
+notify = []
+observability = []
+

crates/config/src/config.rs

@@ -1,116 +0,0 @@
-use crate::ObservabilityConfig;
-
-/// RustFs configuration
-pub struct RustFsConfig {
-    pub observability: ObservabilityConfig,
-}
-
-impl RustFsConfig {
-    pub fn new() -> Self {
-        Self {
-            observability: ObservabilityConfig::new(),
-        }
-    }
-}
-
-impl Default for RustFsConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_rustfs_config_new() {
-        let config = RustFsConfig::new();
-
-        // Verify that observability config is properly initialized
-        assert!(!config.observability.sinks.is_empty(), "Observability sinks should not be empty");
-        assert!(config.observability.logger.is_some(), "Logger config should be present");
-    }
-
-    #[test]
-    fn test_rustfs_config_default() {
-        let config = RustFsConfig::default();
-
-        // Default should be equivalent to new()
-        let new_config = RustFsConfig::new();
-
-        // Compare observability config
-        assert_eq!(config.observability.sinks.len(), new_config.observability.sinks.len());
-        assert_eq!(config.observability.logger.is_some(), new_config.observability.logger.is_some());
-    }
-
-    #[test]
-    fn test_rustfs_config_components_independence() {
-        let mut config = RustFsConfig::new();
-
-        // Modify observability config
-        config.observability.sinks.clear();
-
-        // Create new config to verify independence
-        let new_config = RustFsConfig::new();
-        assert!(!new_config.observability.sinks.is_empty(), "New config should have default sinks");
-    }
-
-    #[test]
-    fn test_rustfs_config_observability_integration() {
-        let config = RustFsConfig::new();
-
-        // Test observability config properties
-        assert!(config.observability.otel.endpoint.is_empty() || !config.observability.otel.endpoint.is_empty());
-        assert!(config.observability.otel.use_stdout.is_some());
-        assert!(config.observability.otel.sample_ratio.is_some());
-        assert!(config.observability.otel.meter_interval.is_some());
-        assert!(config.observability.otel.service_name.is_some());
-        assert!(config.observability.otel.service_version.is_some());
-        assert!(config.observability.otel.environment.is_some());
-        assert!(config.observability.otel.logger_level.is_some());
-    }
-
-    #[test]
-    fn test_rustfs_config_memory_usage() {
-        // Test that config doesn't use excessive memory
-        let config = RustFsConfig::new();
-
-        // Basic memory usage checks
-        assert!(std::mem::size_of_val(&config) < 10000, "Config should not use excessive memory");
-
-        // Test that collections are reasonably sized
-        assert!(config.observability.sinks.len() < 100, "Sinks collection should be reasonably sized");
-    }
-
-    #[test]
-    fn test_rustfs_config_serialization_compatibility() {
-        let config = RustFsConfig::new();
-
-        // Test that observability config can be serialized (it has Serialize trait)
-        let observability_json = serde_json::to_string(&config.observability);
-        assert!(observability_json.is_ok(), "Observability config should be serializable");
-    }
-
-    #[test]
-    fn test_rustfs_config_debug_format() {
-        let config = RustFsConfig::new();
-
-        // Test that observability config has Debug trait
-        let observability_debug = format!("{:?}", config.observability);
-        assert!(!observability_debug.is_empty(), "Observability config should have debug output");
-        assert!(
-            observability_debug.contains("ObservabilityConfig"),
-            "Debug output should contain type name"
-        );
-    }
-
-    #[test]
-    fn test_rustfs_config_clone_behavior() {
-        let config = RustFsConfig::new();
-
-        // Test that observability config can be cloned
-        let observability_clone = config.observability.clone();
-        assert_eq!(observability_clone.sinks.len(), config.observability.sinks.len());
-    }
-}

crates/config/src/lib.rs

@@ -1,9 +1,10 @@
-use crate::observability::config::ObservabilityConfig;
-
-mod config;
-mod constants;
-mod notify;
-mod observability;
-
-pub use config::RustFsConfig;
+#[cfg(feature = "constants")]
+pub mod constants;
+#[cfg(feature = "constants")]
 pub use constants::app::*;
+
+#[cfg(feature = "notify")]
+pub mod notify;
+
+#[cfg(feature = "observability")]
+pub mod observability;

crates/config/src/notify/mod.rs

@@ -1,5 +1,5 @@
 pub mod config;
-pub mod webhook;
-pub mod mqtt;
 pub mod help;
 pub mod legacy;
+pub mod mqtt;
+pub mod webhook;

crates/notify/Cargo.toml

@@ -14,7 +14,6 @@ kafka = ["dep:rdkafka"]
 
 [dependencies]
 async-trait = { workspace = true }
-config = { workspace = true }
 common = { workspace = true }
 ecstore = { workspace = true }
 lazy_static = { workspace = true }

crates/notify/src/error.rs

@@ -1,4 +1,3 @@
-use config::ConfigError;
 use thiserror::Error;
 use tokio::sync::mpsc::error;
 use tokio::task::JoinError;
@@ -35,8 +34,6 @@ pub enum Error {
     Custom(String),
     #[error("Configuration error: {0}")]
     ConfigError(String),
-    #[error("Configuration loading error: {0}")]
-    Config(#[from] ConfigError),
     #[error("create adapter failed error: {0}")]
     AdapterCreationFailed(String),
 }
@@ -150,20 +147,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_config_error_conversion() {
-        // Test configuration error conversion
-        let config_error = ConfigError::Message("invalid configuration".to_string());
-        let converted_error: Error = config_error.into();
-
-        match converted_error {
-            Error::Config(_) => {
-                assert!(converted_error.to_string().contains("Configuration loading error"));
-            }
-            _ => panic!("Expected Config error variant"),
-        }
-    }
-
     #[tokio::test]
     async fn test_channel_send_error_conversion() {
         // Test channel send error conversion

crates/obs/Cargo.toml

@@ -17,7 +17,7 @@ webhook = ["dep:reqwest"]
 kafka = ["dep:rdkafka"]
 
 [dependencies]
-rustfs-config = { workspace = true }
+rustfs-config = { workspace = true, features = ["constants"] }
 async-trait = { workspace = true }
 chrono = { workspace = true }
 flexi_logger = { workspace = true, features = ["trc", "kv"] }

crates/utils/Cargo.toml

@@ -8,7 +8,7 @@ version.workspace = true
 
 [dependencies]
 local-ip-address = { workspace = true, optional = true }
-rustfs-config = { workspace = true }
+rustfs-config = { workspace = true, features = ["constants"] }
 rustls = { workspace = true, optional = true }
 rustls-pemfile = { workspace = true, optional = true }
 rustls-pki-types = { workspace = true, optional = true }