Use dashmap to record recent release access to avoid locking

Author: Nemo157

Cargo.lock

@@ -45,6 +45,7 @@ once_cell = { version = "1.4.0", features = ["parking_lot"] }
 base64 = "0.12.1"
 strum = { version = "0.18.0", features = ["derive"] }
 lol_html = "0.2"
+dashmap = "3.11.10"
 
 # Async
 tokio = { version = "0.2.22", features = ["rt-threaded"] }

Cargo.toml

@@ -1,12 +1,13 @@
 #[macro_use]
 mod macros;
 
-use std::{time::{Duration, Instant}, collections::HashMap, sync::Mutex};
+use std::time::{Duration, Instant};
 use self::macros::MetricFromOpts;
 use crate::db::Pool;
 use crate::BuildQueue;
 use failure::Error;
 use prometheus::proto::MetricFamily;
+use dashmap::DashMap;
 
 load_metric_type!(IntGauge as single);
 load_metric_type!(IntCounter as single);
@@ -76,30 +77,26 @@ metrics! {
     namespace: "docsrs",
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub(crate) struct RecentReleases {
-    krates: Mutex<HashMap<String, Instant>>,
-    versions: Mutex<HashMap<String, Instant>>,
-    platforms: Mutex<HashMap<String, Instant>>,
+    krates: DashMap<String, Instant>,
+    versions: DashMap<String, Instant>,
+    platforms: DashMap<String, Instant>,
 }
 
 impl RecentReleases {
     pub(crate) fn new() -> Self {
-        Self {
-            krates: Mutex::new(HashMap::new()),
-            versions: Mutex::new(HashMap::new()),
-            platforms: Mutex::new(HashMap::new()),
-        }
+        Self::default()
     }
 
     pub(crate) fn record(&self, krate: &str, version: &str, target: &str) {
-        self.krates.lock().unwrap().insert(krate.to_owned(), Instant::now());
-        self.versions.lock().unwrap().insert(format!("{}/{}", krate, version), Instant::now());
-        self.platforms.lock().unwrap().insert(format!("{}/{}/{}", krate, version, target), Instant::now());
+        self.krates.insert(krate.to_owned(), Instant::now());
+        self.versions.insert(format!("{}/{}", krate, version), Instant::now());
+        self.platforms.insert(format!("{}/{}/{}", krate, version, target), Instant::now());
     }
 
     pub(crate) fn gather(&self, metrics: &Metrics) {
-        fn inner(map: &mut HashMap<String, Instant>, metric: &IntGaugeVec) {
+        fn inner(map: &DashMap<String, Instant>, metric: &IntGaugeVec) {
             let mut hour_count = 0;
             let mut half_hour_count = 0;
             let mut five_minute_count = 0;
@@ -133,9 +130,9 @@ impl RecentReleases {
                 .set(five_minute_count);
         }
 
-        inner(&mut *self.krates.lock().unwrap(), &metrics.recent_krates);
-        inner(&mut *self.versions.lock().unwrap(), &metrics.recent_versions);
-        inner(&mut *self.platforms.lock().unwrap(), &metrics.recent_platforms);
+        inner(&self.krates, &metrics.recent_krates);
+        inner(&self.versions, &metrics.recent_versions);
+        inner(&self.platforms, &metrics.recent_platforms);
     }
 }