feat: filter log types using include/exclude patterns

Allow users to filter log types reported by log plugins using
include and exclude patterns in the plugin configuration.

Author: albinsuresh

Cargo.lock

@@ -13,6 +13,8 @@ repository = { workspace = true }
 anyhow = { workspace = true }
 async-trait = { workspace = true }
 camino = { workspace = true }
+glob = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 tedge_actors = { workspace = true }
 tedge_api = { workspace = true }
@@ -30,6 +32,7 @@ tracing = { workspace = true }
 [dev-dependencies]
 tedge_actors = { workspace = true, features = ["test-helpers"] }
 tedge_test_utils = { workspace = true }
+tempfile = { workspace = true }
 time = { workspace = true, features = ["macros"] }
 
 [lints]

crates/extensions/tedge_log_manager/Cargo.toml

@@ -1,6 +1,7 @@
 use super::error::LogManagementError;
 use super::LogManagerConfig;
 use super::DEFAULT_PLUGIN_CONFIG_FILE_NAME;
+use crate::config::PluginConfig;
 use crate::plugin_manager::ExternalPlugins;
 use async_trait::async_trait;
 use std::collections::HashMap;
@@ -59,6 +60,7 @@ pub struct LogManagerActor {
     messages: SimpleMessageBox<LogInput, LogOutput>,
     upload_sender: DynSender<LogUploadRequest>,
     external_plugins: ExternalPlugins,
+    plugin_config: PluginConfig,
 }
 
 #[async_trait]
@@ -97,12 +99,14 @@ impl LogManagerActor {
         upload_sender: DynSender<LogUploadRequest>,
         external_plugins: ExternalPlugins,
     ) -> Self {
+        let plugin_config = PluginConfig::from_file(&config.plugin_config_path);
         Self {
             config,
             pending_operations: HashMap::new(),
             messages,
             upload_sender,
             external_plugins,
+            plugin_config,
         }
     }
 
@@ -280,6 +284,9 @@ impl LogManagerActor {
     async fn reload_supported_log_types(&mut self) -> Result<(), RuntimeError> {
         info!(target: "log plugins", "Reloading supported log types");
 
+        // Reload plugin configuration for up-to-date filtering rules
+        self.plugin_config = PluginConfig::from_file(&self.config.plugin_config_path);
+
         // Note: The log manager now only handles external plugins.
         // The file-based plugin configuration is handled by the standalone plugin.
         self.external_plugins.load().await?;
@@ -305,7 +312,21 @@ impl LogManagerActor {
                             target: "log plugins",
                             "Plugin {} supports log types: {:?}", plugin_type, log_types
                         );
-                        for log_type in log_types {
+
+                        // Apply filtering from plugin config
+                        let filtered_log_types =
+                            self.plugin_config.filter_log_types(&plugin_type, log_types);
+
+                        if !filtered_log_types.is_empty() {
+                            info!(
+                                target: "log plugins",
+                                "Log types from {} plugin after filtering: {:?}",
+                                plugin_type,
+                                filtered_log_types
+                            );
+                        }
+
+                        for log_type in filtered_log_types {
                             if plugin_type == "file" {
                                 // For the file plugin, add log types without suffix (default behavior)
                                 types.push(log_type);

crates/extensions/tedge_log_manager/src/actor.rs

@@ -1,5 +1,7 @@
 use camino::Utf8Path;
 use camino::Utf8PathBuf;
+use serde::Deserialize;
+use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
 use tedge_api::mqtt_topics::Channel;
@@ -87,3 +89,289 @@ impl LogManagerConfig {
         })
     }
 }
+
+/// Plugin filtering configuration parsed from tedge-log-plugin.toml
+#[derive(Clone, Deserialize, Debug, Default, PartialEq, Eq)]
+pub struct PluginConfig {
+    #[serde(default)]
+    pub plugins: HashMap<String, Vec<PluginFilterEntry>>,
+}
+
+/// Individual filter entry for a plugin
+#[derive(Clone, Deserialize, Debug, PartialEq, Eq)]
+pub struct PluginFilterEntry {
+    #[serde(default)]
+    pub include: Option<String>,
+    #[serde(default)]
+    pub exclude: Option<String>,
+}
+
+impl PluginConfig {
+    /// Load plugin configuration from the given path
+    pub fn from_file(path: &std::path::Path) -> Self {
+        match std::fs::read_to_string(path) {
+            Ok(contents) => match toml::from_str(&contents) {
+                Ok(config) => config,
+                Err(err) => {
+                    tracing::warn!(
+                        "Failed to parse plugin config from {}: {}",
+                        path.display(),
+                        err
+                    );
+                    Self::default()
+                }
+            },
+            Err(_) => {
+                // File doesn't exist or not readable - this is OK, just use defaults
+                Self::default()
+            }
+        }
+    }
+
+    pub(crate) fn get_filters(&self, plugin_name: &str) -> Option<&Vec<PluginFilterEntry>> {
+        self.plugins.get(plugin_name)
+    }
+
+    /// Apply filtering to log types from a plugin
+    ///
+    /// Filtering logic:
+    /// - If no filters defined, return all types as-is
+    /// - When only include is specified: only types matching any include filter are returned
+    /// - When only exclude is specified: all types not matching any exclude filter are returned
+    /// - When both are specified: include the types that matches any include filter OR doesn't match any exclude filter
+    pub fn filter_log_types(&self, plugin_name: &str, log_types: Vec<String>) -> Vec<String> {
+        let Some(filters) = self.get_filters(plugin_name) else {
+            // No filters defined for the plugin type, include all types
+            return log_types;
+        };
+
+        let mut exclude_patterns = Vec::new();
+        let mut include_patterns = Vec::new();
+
+        for filter in filters {
+            if let Some(pattern) = &filter.include {
+                if let Ok(compiled) = glob::Pattern::new(pattern) {
+                    include_patterns.push(compiled);
+                } else {
+                    tracing::warn!(
+                        "Invalid include pattern for plugin {}: {}",
+                        plugin_name,
+                        pattern
+                    );
+                }
+            }
+            if let Some(pattern) = &filter.exclude {
+                if let Ok(compiled) = glob::Pattern::new(pattern) {
+                    exclude_patterns.push(compiled);
+                } else {
+                    tracing::warn!(
+                        "Invalid exclude pattern for plugin {}: {}",
+                        plugin_name,
+                        pattern
+                    );
+                }
+            }
+        }
+
+        // If no filter patterns are defined, include all
+        if include_patterns.is_empty() && exclude_patterns.is_empty() {
+            return log_types;
+        }
+
+        let has_include = !include_patterns.is_empty();
+        let has_exclude = !exclude_patterns.is_empty();
+
+        // include a type if it matches any include pattern OR doesn't match any exclude pattern
+        log_types
+            .into_iter()
+            .filter(|log_type| {
+                let matches_include = include_patterns.iter().any(|p| p.matches(log_type));
+                let matches_exclude = exclude_patterns.iter().any(|p| p.matches(log_type));
+
+                match (has_include, has_exclude) {
+                    (true, true) => {
+                        // Both specified: include if the entry matches include OR doesn't match exclude
+                        matches_include || !matches_exclude
+                    }
+                    (true, false) => {
+                        // Only include specified: entry must match any include filter
+                        matches_include
+                    }
+                    (false, true) => {
+                        // Only exclude specified: entry must not match any exclude filter
+                        !matches_exclude
+                    }
+                    (false, false) => {
+                        // No filter patterns are defined, include
+                        true
+                    }
+                }
+            })
+            .collect()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::config::PluginConfig;
+    use crate::config::PluginFilterEntry;
+    use std::collections::HashMap;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    #[test]
+    fn test_plugin_config_from_toml() {
+        let toml_content = r#"
+[[plugins.journald]]
+include = "ssh"
+
+[[plugins.journald]]
+include = "tedge-agent"
+
+[[plugins.dmesg]]
+exclude = "all"
+
+[[plugins.file]]
+exclude = "unwanted-*"
+"#;
+
+        let mut temp_file = NamedTempFile::new().unwrap();
+        temp_file.write_all(toml_content.as_bytes()).unwrap();
+        temp_file.flush().unwrap();
+
+        let config = PluginConfig::from_file(temp_file.path());
+
+        // Check journald filters
+        let journald_filters = config.get_filters("journald").unwrap();
+        assert_eq!(journald_filters.len(), 2);
+        assert_eq!(journald_filters[0].include.as_ref().unwrap(), "ssh");
+        assert_eq!(journald_filters[1].include.as_ref().unwrap(), "tedge-agent");
+
+        // Check dmesg filters
+        let dmesg_filters = config.get_filters("dmesg").unwrap();
+        assert_eq!(dmesg_filters.len(), 1);
+        assert_eq!(dmesg_filters[0].exclude.as_ref().unwrap(), "all");
+
+        // Check file filters
+        let file_filters = config.get_filters("file").unwrap();
+        assert_eq!(file_filters.len(), 1);
+        assert_eq!(file_filters[0].exclude.as_ref().unwrap(), "unwanted-*");
+    }
+
+    #[test]
+    fn test_plugin_config_no_filters_returns_all() {
+        let config = PluginConfig::default();
+        let log_types: Vec<String> = ["ssh", "tedge-agent", "mosquitto"]
+            .iter()
+            .map(|s| s.to_string())
+            .collect();
+
+        let filtered = config.filter_log_types("journald", log_types.clone());
+        assert_eq!(filtered, log_types);
+    }
+
+    #[test]
+    fn test_plugin_filter_include_only() {
+        let mut plugins = HashMap::new();
+        plugins.insert(
+            "journald".to_string(),
+            vec![
+                PluginFilterEntry {
+                    include: Some("ssh".to_string()),
+                    exclude: None,
+                },
+                PluginFilterEntry {
+                    include: Some("tedge-*".to_string()),
+                    exclude: None,
+                },
+            ],
+        );
+
+        let config = PluginConfig { plugins };
+        let log_types: Vec<String> = ["ssh", "tedge-agent", "mosquitto", "systemd-logind"]
+            .iter()
+            .map(|s| s.to_string())
+            .collect();
+
+        let filtered = config.filter_log_types("journald", log_types);
+        assert_eq!(filtered, vec!["ssh".to_string(), "tedge-agent".to_string()]);
+    }
+
+    #[test]
+    fn test_plugin_filter_exclude_only() {
+        let mut plugins = HashMap::new();
+        plugins.insert(
+            "journald".to_string(),
+            vec![
+                PluginFilterEntry {
+                    include: None,
+                    exclude: Some("mosquitto".to_string()),
+                },
+                PluginFilterEntry {
+                    include: None,
+                    exclude: Some("systemd-*".to_string()),
+                },
+            ],
+        );
+
+        let config = PluginConfig { plugins };
+        let log_types: Vec<String> = [
+            "ssh",
+            "tedge-agent",
+            "mosquitto",
+            "systemd-logind",
+            "systemd-journald",
+        ]
+        .iter()
+        .map(|s| s.to_string())
+        .collect();
+
+        let filtered = config.filter_log_types("journald", log_types);
+        assert_eq!(filtered, vec!["ssh".to_string(), "tedge-agent".to_string()]);
+    }
+
+    #[test]
+    fn test_plugin_filter_combined_include_and_exclude() {
+        let mut plugins = HashMap::new();
+        plugins.insert(
+            "journald".to_string(),
+            vec![
+                PluginFilterEntry {
+                    include: None,
+                    exclude: Some("systemd-*".to_string()),
+                },
+                PluginFilterEntry {
+                    include: Some("systemd-logind".to_string()),
+                    exclude: None,
+                },
+                PluginFilterEntry {
+                    include: Some("tedge-*".to_string()),
+                    exclude: None,
+                },
+            ],
+        );
+
+        let config = PluginConfig { plugins };
+        let log_types: Vec<String> = [
+            "ssh",
+            "tedge-agent",
+            "mosquitto",
+            "systemd-logind",
+            "systemd-journald",
+        ]
+        .iter()
+        .map(|s| s.to_string())
+        .collect();
+
+        let filtered = config.filter_log_types("journald", log_types);
+        assert_eq!(
+            filtered,
+            vec![
+                "ssh".to_string(),
+                "tedge-agent".to_string(),
+                "mosquitto".to_string(),
+                "systemd-logind".to_string()
+            ]
+        );
+    }
+}