chore: upgrade to Rust 2024 edition

Author: chenba

Cargo.lock

@@ -24,7 +24,7 @@ version = "0.21.1"
 authors = [
   "Mozilla Sync Backend Engineering <sync-backend@mozilla.com",
 ]
-edition = "2021"
+edition = "2024"
 rust-version = "1.89"
 license = "MPL-2.0"
 

Cargo.toml

@@ -7,8 +7,8 @@ mod tags;
 
 use std::{
     fmt,
-    sync::atomic::{AtomicU64, Ordering},
     sync::Arc,
+    sync::atomic::{AtomicU64, Ordering},
 };
 
 use actix_web::web;
@@ -17,7 +17,7 @@ use hkdf::Hkdf;
 use serde_json::Value;
 use sha2::Sha256;
 
-pub use metrics::{metrics_from_opts, MetricError, Metrics};
+pub use metrics::{MetricError, Metrics, metrics_from_opts};
 pub use tags::Taggable;
 
 // header statics must be lower case, numbers and symbols per the RFC spec. This reduces chance of error.

syncserver-common/src/lib.rs

@@ -6,7 +6,7 @@ use std::time::Instant;
 use cadence::{
     BufferedUdpMetricSink, Counted, Metric, NopMetricSink, QueuingMetricSink, StatsdClient, Timed,
 };
-use slog::{Key, Record, KV};
+use slog::{KV, Key, Record};
 
 pub use cadence::MetricError;
 
@@ -27,26 +27,26 @@ pub struct Metrics {
 impl Drop for Metrics {
     fn drop(&mut self) {
         let tags = self.tags.clone();
-        if let Some(client) = self.client.as_ref() {
-            if let Some(timer) = self.timer.as_ref() {
-                let lapse = (Instant::now() - timer.start).as_millis() as u64;
-                trace!("⌚ Ending timer at nanos: {:?} : {:?}", &timer.label, lapse; &MetricTags(tags));
-                let mut tagged = client.time_with_tags(&timer.label, lapse);
-                // Include any "hard coded" tags.
-                // tagged = tagged.with_tag("version", env!("CARGO_PKG_VERSION"));
-                let tags = timer.tags.clone();
-                let keys = tags.keys();
-                for tag in keys {
-                    tagged = tagged.with_tag(tag, tags.get(tag).unwrap())
+        if let Some(client) = self.client.as_ref()
+            && let Some(timer) = self.timer.as_ref()
+        {
+            let lapse = (Instant::now() - timer.start).as_millis() as u64;
+            trace!("⌚ Ending timer at nanos: {:?} : {:?}", &timer.label, lapse; &MetricTags(tags));
+            let mut tagged = client.time_with_tags(&timer.label, lapse);
+            // Include any "hard coded" tags.
+            // tagged = tagged.with_tag("version", env!("CARGO_PKG_VERSION"));
+            let tags = timer.tags.clone();
+            let keys = tags.keys();
+            for tag in keys {
+                tagged = tagged.with_tag(tag, tags.get(tag).unwrap())
+            }
+            match tagged.try_send() {
+                Err(e) => {
+                    // eat the metric, but log the error
+                    warn!("⚠️ Metric {} error: {:?} ", &timer.label, e);
                 }
-                match tagged.try_send() {
-                    Err(e) => {
-                        // eat the metric, but log the error
-                        warn!("⚠️ Metric {} error: {:?} ", &timer.label, e);
-                    }
-                    Ok(v) => {
-                        trace!("⌚ {:?}", v.as_metric_str());
-                    }
+                Ok(v) => {
+                    trace!("⌚ {:?}", v.as_metric_str());
                 }
             }
         }

syncserver-common/src/metrics.rs

@@ -1,13 +1,13 @@
 use std::{cell::RefCell, collections::BTreeMap, marker::PhantomData, rc::Rc, sync::Arc};
 
 use actix_web::{
-    dev::{Service, ServiceRequest, ServiceResponse, Transform},
     Error,
+    dev::{Service, ServiceRequest, ServiceResponse, Transform},
 };
 use cadence::{CountedExt, StatsdClient};
-use futures::{future::LocalBoxFuture, FutureExt};
-use futures_util::future::{ok, Ready};
-use sentry::{protocol::Event, Hub};
+use futures::{FutureExt, future::LocalBoxFuture};
+use futures_util::future::{Ready, ok};
+use sentry::{Hub, protocol::Event};
 
 use crate::{ReportableError, Taggable};
 
@@ -110,12 +110,12 @@ where
             };
             // Check for errors inside the response
             if let Some(error) = response.response().error() {
-                if let Some(reportable_err) = error.as_error::<E>() {
-                    if !reportable_err.is_sentry_event() {
-                        maybe_emit_metrics(&metrics, reportable_err);
-                        debug!("Not reporting error (service error): {:?}", error);
-                        return Ok(response);
-                    }
+                if let Some(reportable_err) = error.as_error::<E>()
+                    && !reportable_err.is_sentry_event()
+                {
+                    maybe_emit_metrics(&metrics, reportable_err);
+                    debug!("Not reporting error (service error): {:?}", error);
+                    return Ok(response);
                 }
                 debug!("Reporting error to Sentry (response error): {}", error);
                 let event = event_from_actix_error::<E>(error);

syncserver-common/src/middleware/sentry.rs

@@ -2,7 +2,7 @@ use std::fmt;
 
 use backtrace::Backtrace;
 use http::StatusCode;
-use syncserver_common::{from_error, impl_fmt_display, ReportableError};
+use syncserver_common::{ReportableError, from_error, impl_fmt_display};
 use thiserror::Error;
 
 /// Error specific to any SQL database backend. These errors are not related to the syncstorage

syncserver-db-common/src/error.rs

@@ -5,10 +5,10 @@ use std::{error::Error, fmt::Debug};
 
 #[cfg(debug_assertions)]
 use diesel::connection::InstrumentationEvent;
-use diesel::{result::ConnectionResult, Connection};
+use diesel::{Connection, result::ConnectionResult};
 use diesel_async::{
-    async_connection_wrapper::AsyncConnectionWrapper, pooled_connection::ManagerConfig,
-    AsyncConnection, AsyncMigrationHarness,
+    AsyncConnection, AsyncMigrationHarness, async_connection_wrapper::AsyncConnectionWrapper,
+    pooled_connection::ManagerConfig,
 };
 use diesel_migrations::{EmbeddedMigrations, MigrationHarness};
 use tokio::task::spawn_blocking;

syncserver-db-common/src/lib.rs

@@ -1,5 +1,5 @@
 use deadpool::managed::{HookError, HookResult};
-use diesel_async::{pooled_connection::PoolError, AsyncConnection};
+use diesel_async::{AsyncConnection, pooled_connection::PoolError};
 
 pub async fn test_transaction_hook<T>(conn: &mut T) -> HookResult<PoolError>
 where

syncserver-db-common/src/test.rs

@@ -15,3 +15,6 @@ syncserver-common = { path = "../syncserver-common" }
 syncstorage-settings = { path = "../syncstorage-settings" }
 tokenserver-settings = { path = "../tokenserver-settings" }
 url = "2.1"
+
+[dev-dependencies]
+temp-env = "0.3"

syncserver-settings/Cargo.toml

@@ -280,22 +280,27 @@ impl<'d> Deserialize<'d> for Secrets {
 
 #[cfg(test)]
 mod test {
-    use std::env;
-
     use super::*;
 
     #[test]
     fn test_environment_variable_prefix() {
         // Setting an environment variable with the correct prefix correctly sets the setting
         // (note that the default value for the settings.tokenserver.enabled setting is false)
-        env::set_var("SYNC_TOKENSERVER__ENABLED", "true");
-        let settings = Settings::with_env_and_config_file(None).unwrap();
-        assert!(settings.tokenserver.enabled);
+        temp_env::with_var("SYNC_TOKENSERVER__ENABLED", Some("true"), || {
+            let settings = Settings::with_env_and_config_file(None).unwrap();
+            assert!(settings.tokenserver.enabled);
+        });
 
         // Setting an environment variable with the incorrect prefix does not set the setting
-        env::remove_var("SYNC_TOKENSERVER__ENABLED");
-        env::set_var("SYNC__TOKENSERVER__ENABLED", "true");
-        let settings = Settings::with_env_and_config_file(None).unwrap();
-        assert!(!settings.tokenserver.enabled);
+        temp_env::with_vars(
+            [
+                ("SYNC_TOKENSERVER__ENABLED", None),
+                ("SYNC__TOKENSERVER__ENABLED", Some("true")),
+            ],
+            || {
+                let settings = Settings::with_env_and_config_file(None).unwrap();
+                assert!(!settings.tokenserver.enabled);
+            },
+        );
     }
 }