chore: switch to Rust 2024 edition (#1269)

* chore: run `cargo fix --edition --all-features`

* chore: set the edition to 2024

* chore: bump workspace resolver version

* style: modify `match` clauses introduced by migration

* chore: reformat project

* style: remove TODOs about manipulating env vars in single-threaded code

Author: DavSanchez

Cargo.toml

@@ -1,11 +1,11 @@
 [workspace]
-resolver = "2"
+resolver = "3"
 
 members = ["agent-control", "resource-detection", "fs", "wrapper_with_default"]
 
 [workspace.package]
 authors = ["The New Relic Agent Control Team"]
-edition = "2021"
+edition = "2024"
 publish = false
 rust-version = "1.85.0"
 license-file = "./LICENSE.md"
@@ -49,4 +49,4 @@ reqwest = { version = "0.12.11", default-features = false, features = [
 strip = "debuginfo"
 
 [workspace.metadata.cargo-shear]
-ignored = ["mockall_double"]
+ignored = ["mockall_double"]

agent-control/src/agent_control/agent_control.rs

@@ -9,8 +9,8 @@ use crate::agent_control::config_validator::DynamicConfigValidator;
 use crate::agent_control::error::AgentError;
 use crate::agent_control::uptime_report::UptimeReporter;
 use crate::event::{
-    channel::{EventConsumer, EventPublisher},
     AgentControlEvent, ApplicationEvent, OpAMPEvent, SubAgentEvent,
+    channel::{EventConsumer, EventPublisher},
 };
 use crate::opamp::remote_config::report::OpampRemoteConfigStatus;
 use crate::opamp::{
@@ -436,18 +436,18 @@ fn sub_agents_difference<'a>(
 
 #[cfg(test)]
 mod tests {
+    use crate::agent_control::AgentControl;
     use crate::agent_control::agent_control::sub_agents_difference;
     use crate::agent_control::agent_id::AgentID;
     use crate::agent_control::config::{
         AgentControlConfig, AgentControlDynamicConfig, SubAgentConfig,
     };
     use crate::agent_control::config_storer::loader_storer::tests::MockAgentControlDynamicConfigStore;
-    use crate::agent_control::config_validator::tests::MockDynamicConfigValidator;
     use crate::agent_control::config_validator::DynamicConfigValidatorError;
+    use crate::agent_control::config_validator::tests::MockDynamicConfigValidator;
+    use crate::agent_control::resource_cleaner::ResourceCleanerError;
     use crate::agent_control::resource_cleaner::no_op::NoOpResourceCleaner;
     use crate::agent_control::resource_cleaner::tests::MockResourceCleaner;
-    use crate::agent_control::resource_cleaner::ResourceCleanerError;
-    use crate::agent_control::AgentControl;
     use crate::agent_type::agent_type_id::AgentTypeID;
     use crate::agent_type::agent_type_registry::AgentRepositoryError;
     use crate::event::channel::pub_sub;
@@ -460,7 +460,7 @@ mod tests {
     use crate::sub_agent::health::health_checker::{Healthy, Unhealthy};
     use crate::sub_agent::tests::MockStartedSubAgent;
     use crate::sub_agent::tests::MockSubAgentBuilder;
-    use mockall::{predicate, Sequence};
+    use mockall::{Sequence, predicate};
     use std::collections::HashMap;
     use std::sync::Arc;
     use std::thread::{sleep, spawn};
@@ -1113,9 +1113,11 @@ agents:
             )]))),
         );
 
-        assert!(agent_control
-            .apply_remote_agent_control_config(&remote_config, &mut running_sub_agents)
-            .is_err());
+        assert!(
+            agent_control
+                .apply_remote_agent_control_config(&remote_config, &mut running_sub_agents)
+                .is_err()
+        );
 
         assert_eq!(running_sub_agents.len(), 1);
 
@@ -1380,9 +1382,12 @@ agents:
         let ev = agent_control_consumer.as_ref().recv().unwrap();
         assert_eq!(expected, ev);
 
-        let expected = AgentControlEvent::AgentControlBecameUnhealthy(Unhealthy::new(String::default(),  String::from(
-            "Error applying Agent Control remote config: remote config error: `config hash: `a-hash` config error: `some error message``",
-        )));
+        let expected = AgentControlEvent::AgentControlBecameUnhealthy(Unhealthy::new(
+            String::default(),
+            String::from(
+                "Error applying Agent Control remote config: remote config error: `config hash: `a-hash` config error: `some error message``",
+            ),
+        ));
         let ev = agent_control_consumer.as_ref().recv().unwrap();
         assert_eq!(expected, ev);
     }
@@ -1647,12 +1652,14 @@ agents:
         let diff: Vec<_> = sub_agents_difference(&old_sub_agents, &new_sub_agents).collect();
 
         assert_eq!(diff.len(), 2);
-        assert!(diff
-            .iter()
-            .any(|(id, _)| id == &&AgentID::new("infra-agent").unwrap()));
-        assert!(diff
-            .iter()
-            .any(|(id, _)| id == &&AgentID::new("nrdot").unwrap()));
+        assert!(
+            diff.iter()
+                .any(|(id, _)| id == &&AgentID::new("infra-agent").unwrap())
+        );
+        assert!(
+            diff.iter()
+                .any(|(id, _)| id == &&AgentID::new("nrdot").unwrap())
+        );
     }
 
     #[test]

agent-control/src/agent_control/agent_id.rs

@@ -17,7 +17,9 @@ pub struct AgentID(String);
 
 #[derive(Error, Debug)]
 pub enum AgentIDError {
-    #[error("AgentID must contain 32 characters at most, contain lowercase alphanumeric characters or dashes only, start with alphabetic, and end with alphanumeric")]
+    #[error(
+        "AgentID must contain 32 characters at most, contain lowercase alphanumeric characters or dashes only, start with alphabetic, and end with alphanumeric"
+    )]
     InvalidFormat,
     #[error("AgentID '{0}' is reserved")]
     Reserved(String),

agent-control/src/agent_control/config.rs

@@ -4,8 +4,8 @@ use super::uptime_report::UptimeReportConfig;
 use crate::http::config::ProxyConfig;
 use crate::instrumentation::config::logs::config::LoggingConfig;
 use crate::opamp::auth::config::AuthConfig;
-use crate::opamp::remote_config::validators::signature::validator::SignatureValidatorConfig;
 use crate::opamp::remote_config::RemoteConfigError;
+use crate::opamp::remote_config::validators::signature::validator::SignatureValidatorConfig;
 use crate::values::yaml_config::YAMLConfig;
 use crate::{
     agent_type::agent_type_id::AgentTypeID, instrumentation::config::InstrumentationConfig,
@@ -390,10 +390,12 @@ agents: {}
             serde_yaml::from_str::<AgentControlDynamicConfig>(EXAMPLE_SUBAGENTS_CONFIG).is_ok()
         );
         assert!(serde_yaml::from_str::<AgentControlDynamicConfig>(EXAMPLE_K8S_CONFIG).is_ok());
-        assert!(serde_yaml::from_str::<AgentControlDynamicConfig>(
-            EXAMPLE_AGENTCONTROL_CONFIG_EMPTY_AGENTS
-        )
-        .is_ok());
+        assert!(
+            serde_yaml::from_str::<AgentControlDynamicConfig>(
+                EXAMPLE_AGENTCONTROL_CONFIG_EMPTY_AGENTS
+            )
+            .is_ok()
+        );
         assert!(
             serde_yaml::from_str::<AgentControlConfig>(EXAMPLE_AGENTCONTROL_CONFIG_NO_AGENTS)
                 .is_err()
@@ -418,21 +420,25 @@ agents: {}
         let actual =
             serde_yaml::from_str::<AgentControlConfig>(AGENTCONTROL_CONFIG_RESERVED_AGENT_ID);
         assert!(actual.is_err());
-        assert!(actual
-            .unwrap_err()
-            .to_string()
-            .contains("AgentID 'agent-control' is reserved at line"))
+        assert!(
+            actual
+                .unwrap_err()
+                .to_string()
+                .contains("AgentID 'agent-control' is reserved at line")
+        )
     }
 
     #[test]
     fn parse_with_missing_k8s_fields() {
         let actual =
             serde_yaml::from_str::<AgentControlConfig>(AGENTCONTROL_CONFIG_MISSING_K8S_FIELDS);
         assert!(actual.is_err());
-        assert!(actual
-            .unwrap_err()
-            .to_string()
-            .contains("k8s: missing field"));
+        assert!(
+            actual
+                .unwrap_err()
+                .to_string()
+                .contains("k8s: missing field")
+        );
     }
 
     #[test]

agent-control/src/agent_control/config_storer/store.rs

@@ -6,7 +6,7 @@ use crate::agent_control::config_storer::loader_storer::{
     AgentControlConfigLoader, AgentControlDynamicConfigDeleter, AgentControlDynamicConfigLoader,
     AgentControlDynamicConfigStorer,
 };
-use crate::agent_control::defaults::{default_capabilities, AGENT_CONTROL_CONFIG_ENV_VAR_PREFIX};
+use crate::agent_control::defaults::{AGENT_CONTROL_CONFIG_ENV_VAR_PREFIX, default_capabilities};
 use crate::values::yaml_config::{YAMLConfig, YAMLConfigError};
 use crate::values::yaml_config_repository::{YAMLConfigRepository, YAMLConfigRepositoryError};
 use config::builder::DefaultState;
@@ -210,7 +210,7 @@ fleet_control:
         // We set the environment variable with the `__` separator which will create the nested
         // configs appropriately.
         let env_var_name = "NR_AC_AGENTS__ROLLDICE1__AGENT_TYPE";
-        env::set_var(env_var_name, "namespace/com.newrelic.infrastructure:0.0.2");
+        unsafe { env::set_var(env_var_name, "namespace/com.newrelic.infrastructure:0.0.2") };
 
         let vr = YAMLConfigRepositoryFile::new(local_dir, PathBuf::new()).with_remote();
         let store = AgentControlConfigStore::new(Arc::new(vr));
@@ -236,7 +236,7 @@ fleet_control:
         };
 
         // Env cleanup
-        env::remove_var(env_var_name);
+        unsafe { env::remove_var(env_var_name) };
 
         assert_eq!(actual, expected);
     }
@@ -258,7 +258,7 @@ agents:
         // We set the environment variable with the `__` separator which will create the nested
         // configs appropriately.
         let env_var_name = "NR_AC_AGENTS__ROLLDICE2__AGENT_TYPE";
-        env::set_var(env_var_name, "namespace/com.newrelic.infrastructure:0.0.2");
+        unsafe { env::set_var(env_var_name, "namespace/com.newrelic.infrastructure:0.0.2") };
 
         let vr = YAMLConfigRepositoryFile::new(local_dir, PathBuf::new()).with_remote();
         let store = AgentControlConfigStore::new(Arc::new(vr));
@@ -284,7 +284,7 @@ agents:
         };
 
         // Env cleanup
-        env::remove_var(env_var_name);
+        unsafe { env::remove_var(env_var_name) };
 
         assert_eq!(actual, expected);
     }

agent-control/src/agent_control/event_handler/opamp/remote_config.rs

@@ -9,7 +9,7 @@ use crate::sub_agent::health::health_checker::{Healthy, Unhealthy};
 use crate::{
     agent_control::{agent_control::AgentControl, error::AgentError},
     opamp::{hash_repository::HashRepository, remote_config::RemoteConfig},
-    sub_agent::{collection::StartedSubAgents, NotStartedSubAgent, SubAgentBuilder},
+    sub_agent::{NotStartedSubAgent, SubAgentBuilder, collection::StartedSubAgents},
 };
 use opamp_client::StartedClient;
 use tracing::{error, info};
@@ -82,7 +82,7 @@ mod tests {
         opamp::{
             client_builder::tests::MockStartedOpAMPClient,
             hash_repository::repository::tests::MockHashRepository,
-            remote_config::{hash::Hash, ConfigurationMap, RemoteConfig},
+            remote_config::{ConfigurationMap, RemoteConfig, hash::Hash},
         },
         sub_agent::{
             collection::StartedSubAgents,

agent-control/src/agent_control/http_server/async_bridge.rs

@@ -15,49 +15,51 @@ pub fn run_async_sync_bridge(
     sub_agent_consumer: EventConsumer<SubAgentEvent>,
     stop_rx: EventConsumer<()>,
 ) -> JoinHandle<()> {
-    spawn_named_thread("Async-Sync bridge", move || loop {
-        select! {
-            recv(&agent_control_consumer.as_ref()) -> sa_event_res => {
-                match sa_event_res {
-                    Ok(agent_control_event) => {
-                        let _ = async_sa_publisher.send(agent_control_event).inspect_err(|err| {
-                            error!(
+    spawn_named_thread("Async-Sync bridge", move || {
+        loop {
+            select! {
+                recv(&agent_control_consumer.as_ref()) -> sa_event_res => {
+                    match sa_event_res {
+                        Ok(agent_control_event) => {
+                            let _ = async_sa_publisher.send(agent_control_event).inspect_err(|err| {
+                                error!(
+                                    error_msg = %err,
+                                    "cannot forward agent control event"
+                                );
+                            });
+                        }
+                        Err(err) => {
+                            debug!(
                                 error_msg = %err,
-                                "cannot forward agent control event"
+                                "status server bridge channel closed"
                             );
-                        });
+                            break;
+                        }
                     }
-                    Err(err) => {
-                        debug!(
-                            error_msg = %err,
-                            "status server bridge channel closed"
-                        );
-                        break;
-                    }
-                }
-            },
-            recv(&sub_agent_consumer.as_ref()) -> suba_event_res => {
-                match suba_event_res {
-                    Ok(sub_agent_event) => {
-                        let _ = async_suba_publisher.send(sub_agent_event).inspect_err(|err| {
-                            error!(
+                },
+                recv(&sub_agent_consumer.as_ref()) -> suba_event_res => {
+                    match suba_event_res {
+                        Ok(sub_agent_event) => {
+                            let _ = async_suba_publisher.send(sub_agent_event).inspect_err(|err| {
+                                error!(
+                                    error_msg = %err,
+                                    "cannot forward agent control event"
+                                );
+                            });
+                        }
+                        Err(err) => {
+                            debug!(
                                 error_msg = %err,
-                                "cannot forward agent control event"
+                                "status server bridge channel closed"
                             );
-                        });
-                    }
-                    Err(err) => {
-                        debug!(
-                            error_msg = %err,
-                            "status server bridge channel closed"
-                        );
-                        break;
+                            break;
+                        }
                     }
+                },
+                recv(&stop_rx.as_ref()) -> _ => {
+                    debug!("status server bridge stopping");
+                    break;
                 }
-            },
-            recv(&stop_rx.as_ref()) -> _ => {
-                debug!("status server bridge stopping");
-                break;
             }
         }
     })

agent-control/src/agent_control/http_server/config.rs

@@ -53,7 +53,7 @@ impl Display for Host {
 #[cfg(test)]
 mod tests {
     use crate::agent_control::http_server::config::{
-        Host, Port, ServerConfig, DEFAULT_HOST, DEFAULT_PORT,
+        DEFAULT_HOST, DEFAULT_PORT, Host, Port, ServerConfig,
     };
     use serde::Deserialize;
 

agent-control/src/agent_control/http_server/runner.rs

@@ -164,8 +164,8 @@ mod tests {
     use tracing_test::traced_test;
 
     use crate::agent_control::http_server::config::ServerConfig;
-    use crate::event::channel::pub_sub;
     use crate::event::AgentControlEvent;
+    use crate::event::channel::pub_sub;
 
     use super::Runner;
 

agent-control/src/agent_control/http_server/server.rs

@@ -1,16 +1,16 @@
 use crate::agent_control::config::OpAMPClientConfig;
-use crate::agent_control::http_server::config::{ServerConfig, DEFAULT_WORKERS};
+use crate::agent_control::http_server::StatusServerError;
+use crate::agent_control::http_server::config::{DEFAULT_WORKERS, ServerConfig};
 use crate::agent_control::http_server::status::Status;
 use crate::agent_control::http_server::status_handler::status_handler;
 use crate::agent_control::http_server::status_updater::on_agent_control_event_update_status;
-use crate::agent_control::http_server::StatusServerError;
 use crate::event::{AgentControlEvent, SubAgentEvent};
-use actix_web::{dev::ServerHandle, web, App, HttpServer};
-use std::sync::mpsc;
+use actix_web::{App, HttpServer, dev::ServerHandle, web};
 use std::sync::Arc;
+use std::sync::mpsc;
 use tokio::runtime::Handle;
-use tokio::sync::mpsc::UnboundedReceiver;
 use tokio::sync::RwLock;
+use tokio::sync::mpsc::UnboundedReceiver;
 use tracing::{debug, error, info};
 
 pub async fn run_status_server(