fix(server): optimize log rotation and fix active log file deletion issues

- Rename variables (max_size => max_file_size, internal attributions)
- Configure customize rotation check option and redirect default unwrap values
- Fix prevention of active log file deletion
- Optimize thread handling (graceful shutdown, thread communication)
- Validate invalid configuration parameters
- Sync e2e/server.toml configuration
- Use full semantic versioning for dependencies

Author: Svecco

core/configs/server.toml

@@ -363,12 +363,17 @@ level = "info"
 # When enabled, logs are stored in {system.path}/{system.logging.path} (default: local_data/logs).
 file_enabled = true
 
-# Maximum size of the log files before rotation.
-max_size = "512 MB"
+# Maximum size of a single log file before rotation occurs.
+# When a log file reaches this size, it will be rotated (closed and a new file created).
+# This setting works together with max_total_size to control log storage.
+max_file_size = "512 MB"
 
 # Maximum total size of all log files combined.
 # When this size is reached, oldest files will be deleted.
-max_total_size = "10 GB"
+max_total_size = "4 GB"
+
+# Time interval for checking log file size and rotation.
+rotation_check_interval = "1 h"
 
 # Time to retain log files before deletion.
 retention = "7 days"

core/server/Cargo.toml

@@ -67,7 +67,7 @@ error_set = { workspace = true }
 figlet-rs = { workspace = true }
 figment = { workspace = true }
 flume = { workspace = true }
-fs2 = "0.4"
+fs2 = "0.4.3"
 futures = { workspace = true }
 hash32 = "1.0.0"
 human-repr = { workspace = true }

core/server/src/configs/defaults.rs

@@ -402,8 +402,14 @@ impl Default for LoggingConfig {
             path: SERVER_CONFIG.system.logging.path.parse().unwrap(),
             level: SERVER_CONFIG.system.logging.level.parse().unwrap(),
             file_enabled: SERVER_CONFIG.system.logging.file_enabled,
-            max_size: SERVER_CONFIG.system.logging.max_size.parse().unwrap(),
+            max_file_size: SERVER_CONFIG.system.logging.max_file_size.parse().unwrap(),
             max_total_size: SERVER_CONFIG.system.logging.max_total_size.parse().unwrap(),
+            rotation_check_interval: SERVER_CONFIG
+                .system
+                .logging
+                .rotation_check_interval
+                .parse()
+                .unwrap(),
             retention: SERVER_CONFIG.system.logging.retention.parse().unwrap(),
             sysinfo_print_interval: SERVER_CONFIG
                 .system

core/server/src/configs/displays.rs

@@ -170,7 +170,7 @@ impl Display for ServerConfig {
 }
 
 impl Display for MessageSaverConfig {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         write!(
             f,
             "{{ enabled: {}, enforce_fsync: {}, interval: {} }}",
@@ -253,7 +253,7 @@ impl Display for LoggingConfig {
             self.path,
             self.level,
             self.file_enabled,
-            self.max_size.as_human_string_with_zero_as_unlimited(),
+            self.max_file_size.as_human_string_with_zero_as_unlimited(),
             self.retention
         )
     }

core/server/src/configs/system.rs

@@ -16,13 +16,12 @@
  * under the License.
  */
 
+use super::cache_indexes::CacheIndexesConfig;
+use super::sharding::ShardingConfig;
 use crate::configs::server::MemoryPoolConfig;
 use crate::slab::partitions;
 use crate::slab::streams;
 use crate::slab::topics;
-
-use super::cache_indexes::CacheIndexesConfig;
-use super::sharding::ShardingConfig;
 use iggy_common::IggyByteSize;
 use iggy_common::IggyError;
 use iggy_common::IggyExpiry;
@@ -87,20 +86,16 @@ pub struct LoggingConfig {
     pub path: String,
     pub level: String,
     pub file_enabled: bool,
-    pub max_size: IggyByteSize,
-    #[serde(default = "default_max_total_log_size")]
+    pub max_file_size: IggyByteSize,
     pub max_total_size: IggyByteSize,
     #[serde_as(as = "DisplayFromStr")]
+    pub rotation_check_interval: IggyDuration,
+    #[serde_as(as = "DisplayFromStr")]
     pub retention: IggyDuration,
     #[serde_as(as = "DisplayFromStr")]
     pub sysinfo_print_interval: IggyDuration,
 }
 
-fn default_max_total_log_size() -> IggyByteSize {
-    IggyByteSize::from(10 * 1024 * 1024 * 1024)
-    // 10 GiB by default
-}
-
 #[derive(Debug, Deserialize, Serialize)]
 pub struct EncryptionConfig {
     pub enabled: bool,

core/server/src/configs/validators.rs

@@ -22,7 +22,7 @@ use super::server::{
     DataMaintenanceConfig, MessageSaverConfig, MessagesMaintenanceConfig, TelemetryConfig,
 };
 use super::sharding::{CpuAllocation, ShardingConfig};
-use super::system::{CompressionConfig, PartitionConfig};
+use super::system::{CompressionConfig, LoggingConfig, PartitionConfig};
 use crate::configs::COMPONENT;
 use crate::configs::server::{MemoryPoolConfig, PersonalAccessTokenConfig, ServerConfig};
 use crate::configs::sharding::NumaTopology;
@@ -85,6 +85,13 @@ impl Validatable<ConfigurationError> for ServerConfig {
                 format!("{COMPONENT} (error: {e}) - failed to validate cluster config")
             })?;
 
+        self.system
+            .logging
+            .validate()
+            .error(|e: &iggy_common::ConfigurationError| {
+                format!("{COMPONENT} (error: {e}) - failed to validate logging config")
+            })?;
+
         let topic_size = match self.system.topic.max_size {
             MaxTopicSize::Custom(size) => Ok(size.as_bytes_u64()),
             MaxTopicSize::Unlimited => Ok(u64::MAX),
@@ -255,6 +262,32 @@ impl Validatable<ConfigurationError> for PersonalAccessTokenConfig {
     }
 }
 
+impl Validatable<ConfigurationError> for LoggingConfig {
+    fn validate(&self) -> Result<(), ConfigurationError> {
+        if self.level.is_empty() {
+            return Err(ConfigurationError::InvalidConfigurationValue);
+        }
+
+        if self.retention.as_secs() < 1 {
+            error!(
+                "Configured system.logging.retention {} is less than minimum 1 second",
+                self.retention
+            );
+            return Err(ConfigurationError::InvalidConfigurationValue);
+        }
+
+        if self.max_total_size.as_bytes_u64() < self.max_file_size.as_bytes_u64() {
+            error!(
+                "Configured system.logging.max_total_size {} is less than system.logging.max_file_size {}",
+                self.max_total_size, self.max_file_size
+            );
+            return Err(ConfigurationError::InvalidConfigurationValue);
+        }
+
+        Ok(())
+    }
+}
+
 impl Validatable<ConfigurationError> for MemoryPoolConfig {
     fn validate(&self) -> Result<(), ConfigurationError> {
         if self.enabled && self.size == 0 {