make change_log_ignore a thing

veilid-server/src/client_api.rs

@@ -19,10 +19,10 @@ use wg::AsyncWaitGroup;
 const MAX_NON_JSON_LOGGING: usize = 50;
 
 cfg_if! {
-   
+
     if #[cfg(feature="rt-async-std")] {
         use futures_util::{AsyncBufReadExt, AsyncWriteExt};
-    } else 
+    } else
     if #[cfg(feature="rt-tokio")] {
         use tokio::io::AsyncBufReadExt;
         use tokio::io::AsyncWriteExt;
@@ -93,6 +93,13 @@ impl ClientApi {
         veilid_logs.change_log_level(layer, log_level)
     }
 
+    fn change_log_ignore(&self, layer: String, log_ignore: String) -> VeilidAPIResult<()> {
+        trace!("ClientApi::change_log_ignore");
+
+        let veilid_logs = self.inner.lock().veilid_logs.clone();
+        veilid_logs.change_log_ignore(layer, log_ignore)
+    }
+
     #[instrument(level = "trace", skip(self))]
     pub async fn stop(&self) {
         trace!("ClientApi::stop requested");
@@ -203,6 +210,12 @@ impl ClientApi {
             let log_level = VeilidConfigLogLevel::from_str(&args[2])?;
             self.change_log_level(args[1].clone(), log_level)?;
             Ok("".to_owned())
+        } else if args[0] == "ChangeLogIgnore" {
+            if args.len() != 3 {
+                apibail_generic!("wrong number of arguments");
+            }
+            self.change_log_ignore(args[1].clone(), args[2].clone())?;
+            Ok("".to_owned())
         } else if args[0] == "GetServerSettings" {
             if args.len() != 1 {
                 apibail_generic!("wrong number of arguments");

veilid-server/src/veilid_logs.rs

@@ -229,4 +229,59 @@ impl VeilidLogs {
         }
         Ok(())
     }
+
+    fn apply_ignore_change(ignore_list: Vec<String>, target_change: String) -> Vec<String> {
+        let mut ignore_list = ignore_list.clone();
+
+        for change in target_change.split(',').map(|c| c.trim().to_owned()) {
+            if change.is_empty() {
+                continue;
+            }
+            if let Some(target) = change.strip_prefix('-') {
+                ignore_list.retain(|x| x != target);
+            } else if !ignore_list.contains(&change) {
+                ignore_list.push(change.to_string());
+            }
+        }
+
+        ignore_list
+    }
+
+    pub fn change_log_ignore(
+        &self,
+        layer: String,
+        log_ignore: String,
+    ) -> Result<(), veilid_core::VeilidAPIError> {
+        // get layer to change level on
+        let layer = if layer == "all" { "".to_owned() } else { layer };
+
+        // change log level on appropriate layer
+        let inner = self.inner.lock();
+        if layer.is_empty() {
+            // Change all layers
+            for f in inner.filters.values() {
+                f.set_ignore_list(Some(Self::apply_ignore_change(
+                    f.ignore_list(),
+                    log_ignore.clone(),
+                )));
+            }
+        } else {
+            // Change a specific layer
+            let f = match inner.filters.get(layer.as_str()) {
+                Some(f) => f,
+                None => {
+                    return Err(veilid_core::VeilidAPIError::InvalidArgument {
+                        context: "change_log_level".to_owned(),
+                        argument: "layer".to_owned(),
+                        value: layer,
+                    });
+                }
+            };
+            f.set_ignore_list(Some(Self::apply_ignore_change(
+                f.ignore_list(),
+                log_ignore.clone(),
+            )));
+        }
+        Ok(())
+    }
 }