From 7e549a67cfac346e0a32ea4699c462cc15f42a87 Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Sun, 30 Aug 2020 19:44:10 +0200
Subject: [PATCH 01/10] Add metrics tracking number of recently loaded
 crates/versions/platforms

---
 src/metrics/macros.rs |  2 +
 src/metrics/mod.rs    | 90 +++++++++++++++++++++++++++++++++++++++++++
 src/web/rustdoc.rs    | 14 +++++--
 3 files changed, 102 insertions(+), 4 deletions(-)

diff --git a/src/metrics/macros.rs b/src/metrics/macros.rs
index cf7ccd256..d871be23d 100644
--- a/src/metrics/macros.rs
+++ b/src/metrics/macros.rs
@@ -20,6 +20,7 @@ macro_rules! metrics {
                 $(#[$meta])*
                 $metric_vis $metric: $ty,
             )*
+            pub(crate) recent_releases: RecentReleases,
         }
         impl $name {
             $vis fn new() -> Result<Self, prometheus::Error> {
@@ -36,6 +37,7 @@ macro_rules! metrics {
                 )*
                 Ok(Self {
                     registry,
+                    recent_releases: RecentReleases::new(),
                     $(
                         $(#[$meta])*
                         $metric,
diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index 9f5eabebd..f358fac29 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -6,10 +6,16 @@ use crate::db::Pool;
 use crate::BuildQueue;
 use failure::Error;
 use prometheus::proto::MetricFamily;
+use std::{
+    collections::HashMap,
+    sync::Mutex,
+    time::{Duration, Instant},
+};
 
 load_metric_type!(IntGauge as single);
 load_metric_type!(IntCounter as single);
 load_metric_type!(IntCounterVec as vec);
+load_metric_type!(IntGaugeVec as vec);
 load_metric_type!(HistogramVec as vec);
 
 metrics! {
@@ -44,6 +50,13 @@ metrics! {
         /// The time it takes to render a rustdoc page
         pub(crate) rustdoc_rendering_times: HistogramVec["step"],
 
+        /// Count of recently accessed crates
+        pub(crate) recent_krates: IntGaugeVec["duration"],
+        /// Count of recently accessed versions of crates
+        pub(crate) recent_versions: IntGaugeVec["duration"],
+        /// Count of recently accessed platforms of versions of crates
+        pub(crate) recent_platforms: IntGaugeVec["duration"],
+
         /// Number of crates built
         pub(crate) total_builds: IntCounter,
         /// Number of builds that successfully generated docs
@@ -67,6 +80,82 @@ metrics! {
     namespace: "docsrs",
 }
 
+#[derive(Debug)]
+pub(crate) struct RecentReleases {
+    krates: Mutex<HashMap<String, Instant>>,
+    versions: Mutex<HashMap<String, Instant>>,
+    platforms: Mutex<HashMap<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()),
+        }
+    }
+
+    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());
+    }
+
+    pub(crate) fn gather(&self, metrics: &Metrics) {
+        fn inner(map: &mut HashMap<String, Instant>, metric: &IntGaugeVec) {
+            let mut hour_count = 0;
+            let mut half_hour_count = 0;
+            let mut five_minute_count = 0;
+            map.retain(|_, instant| {
+                let elapsed = instant.elapsed();
+                if elapsed > Duration::from_secs(60 * 60) {
+                    return false;
+                }
+                hour_count += 1;
+                if elapsed > Duration::from_secs(30 * 60) {
+                    return true;
+                }
+                half_hour_count += 1;
+                if elapsed > Duration::from_secs(5 * 60) {
+                    return true;
+                }
+                five_minute_count += 1;
+                true
+            });
+
+            metric.with_label_values(&["one hour"]).set(hour_count);
+
+            metric
+                .with_label_values(&["half hour"])
+                .set(half_hour_count);
+
+            metric
+                .with_label_values(&["five minutes"])
+                .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,
+        );
+    }
+}
+
 impl Metrics {
     pub(crate) fn gather(
         &self,
@@ -82,6 +171,7 @@ impl Metrics {
             .set(queue.prioritized_count()? as i64);
         self.failed_crates_count.set(queue.failed_count()? as i64);
 
+        self.recent_releases.gather(self);
         self.gather_system_performance();
         Ok(self.registry.gather())
     }
diff --git a/src/web/rustdoc.rs b/src/web/rustdoc.rs
index 99a32b829..1f1e15a6e 100644
--- a/src/web/rustdoc.rs
+++ b/src/web/rustdoc.rs
@@ -415,16 +415,22 @@ pub fn rustdoc_html_server_handler(req: &mut Request) -> IronResult<Response> {
                 .iter()
                 .any(|s| s == inner_path[0])
         {
-            let mut target = inner_path.remove(0).to_string();
-            target.push('/');
-            target
+            inner_path.remove(0)
         } else {
-            String::new()
+            ""
         };
 
         (target, inner_path.join("/"))
     };
 
+    metrics.recent_releases.record(&name, &version, target);
+
+    let target = if target == "" {
+        String::new()
+    } else {
+        format!("{}/", target)
+    };
+
     rendering_time.step("rewrite html");
     RustdocPage {
         latest_path,

From 61772650e0e20325f1705b03df9623568ea48549 Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Sun, 30 Aug 2020 19:58:35 +0200
Subject: [PATCH 02/10] Use dashmap to record recent release access to avoid
 locking

---
 Cargo.lock         | 41 +++++++++++++++++++++++++++++++++++++++++
 Cargo.toml         |  1 +
 src/metrics/mod.rs | 44 ++++++++++++--------------------------------
 3 files changed, 54 insertions(+), 32 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3ca1fe649..603e10ccb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -21,6 +21,15 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5d2e7343e7fc9de883d1b0341e0b13970f764c14101234857d2ddafa1cb1cac2"
 
+[[package]]
+name = "ahash"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8fd72866655d1904d6b0997d0b07ba561047d070fbe29de039031c641b61217"
+dependencies = [
+ "const-random",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "0.7.10"
@@ -325,6 +334,26 @@ dependencies = [
  "unicode_categories",
 ]
 
+[[package]]
+name = "const-random"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f1af9ac737b2dd2d577701e59fd09ba34822f6f2ebdb30a7647405d9e55e16a"
+dependencies = [
+ "const-random-macro",
+ "proc-macro-hack",
+]
+
+[[package]]
+name = "const-random-macro"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "25e4c606eb459dd29f7c57b2e0879f2b6f14ee130918c2b78ccb58a9624e6c7a"
+dependencies = [
+ "getrandom",
+ "proc-macro-hack",
+]
+
 [[package]]
 name = "constant_time_eq"
 version = "0.1.5"
@@ -564,6 +593,17 @@ dependencies = [
  "memchr 2.3.3",
 ]
 
+[[package]]
+name = "dashmap"
+version = "3.11.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f260e2fc850179ef410018660006951c1b55b79e8087e87111a2c388994b9b5"
+dependencies = [
+ "ahash",
+ "cfg-if",
+ "num_cpus",
+]
+
 [[package]]
 name = "derive_more"
 version = "0.99.7"
@@ -633,6 +673,7 @@ dependencies = [
  "crates-index",
  "crates-index-diff",
  "criterion",
+ "dashmap",
  "docsrs-metadata",
  "dotenv",
  "env_logger",
diff --git a/Cargo.toml b/Cargo.toml
index 872a05636..55e97e971 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -51,6 +51,7 @@ base64 = "0.12.1"
 strum = { version = "0.18.0", features = ["derive"] }
 lol_html = "0.2"
 font-awesome-as-a-crate = { path = "crates/font-awesome-as-a-crate" }
+dashmap = "3.11.10"
 
 # Async
 tokio = { version = "0.2.22", features = ["rt-threaded"] }
diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index f358fac29..0efb21e0f 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -4,13 +4,10 @@ mod macros;
 use self::macros::MetricFromOpts;
 use crate::db::Pool;
 use crate::BuildQueue;
+use dashmap::DashMap;
 use failure::Error;
 use prometheus::proto::MetricFamily;
-use std::{
-    collections::HashMap,
-    sync::Mutex,
-    time::{Duration, Instant},
-};
+use std::time::{Duration, Instant};
 
 load_metric_type!(IntGauge as single);
 load_metric_type!(IntCounter as single);
@@ -80,39 +77,28 @@ 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.krates.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());
     }
 
     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;
@@ -144,15 +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);
     }
 }
 

From 90632235222875251a9b37f9dd207ab0c0646e6b Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Mon, 31 Aug 2020 18:53:25 +0200
Subject: [PATCH 03/10] Rename recent crate metric

---
 src/metrics/mod.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index 0efb21e0f..cc1a6872f 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -48,7 +48,7 @@ metrics! {
         pub(crate) rustdoc_rendering_times: HistogramVec["step"],
 
         /// Count of recently accessed crates
-        pub(crate) recent_krates: IntGaugeVec["duration"],
+        pub(crate) recent_crates: IntGaugeVec["duration"],
         /// Count of recently accessed versions of crates
         pub(crate) recent_versions: IntGaugeVec["duration"],
         /// Count of recently accessed platforms of versions of crates
@@ -130,7 +130,7 @@ impl RecentReleases {
                 .set(five_minute_count);
         }
 
-        inner(&self.krates, &metrics.recent_krates);
+        inner(&self.krates, &metrics.recent_crates);
         inner(&self.versions, &metrics.recent_versions);
         inner(&self.platforms, &metrics.recent_platforms);
     }

From 27983b0aa5f5d48bd768de87e5c64fd303308975 Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Mon, 31 Aug 2020 18:53:25 +0200
Subject: [PATCH 04/10] Rename recently accessed crate metrics

---
 src/metrics/macros.rs | 4 ++--
 src/metrics/mod.rs    | 6 +++---
 src/web/rustdoc.rs    | 4 +++-
 3 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/metrics/macros.rs b/src/metrics/macros.rs
index d871be23d..22fc97be7 100644
--- a/src/metrics/macros.rs
+++ b/src/metrics/macros.rs
@@ -20,7 +20,7 @@ macro_rules! metrics {
                 $(#[$meta])*
                 $metric_vis $metric: $ty,
             )*
-            pub(crate) recent_releases: RecentReleases,
+            pub(crate) recently_accessed_releases: RecentlyAccessedReleases,
         }
         impl $name {
             $vis fn new() -> Result<Self, prometheus::Error> {
@@ -37,7 +37,7 @@ macro_rules! metrics {
                 )*
                 Ok(Self {
                     registry,
-                    recent_releases: RecentReleases::new(),
+                    recently_accessed_releases: RecentlyAccessedReleases::new(),
                     $(
                         $(#[$meta])*
                         $metric,
diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index cc1a6872f..5eab89089 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -78,13 +78,13 @@ metrics! {
 }
 
 #[derive(Debug, Default)]
-pub(crate) struct RecentReleases {
+pub(crate) struct RecentlyAccessedReleases {
     krates: DashMap<String, Instant>,
     versions: DashMap<String, Instant>,
     platforms: DashMap<String, Instant>,
 }
 
-impl RecentReleases {
+impl RecentlyAccessedReleases {
     pub(crate) fn new() -> Self {
         Self::default()
     }
@@ -151,7 +151,7 @@ impl Metrics {
             .set(queue.prioritized_count()? as i64);
         self.failed_crates_count.set(queue.failed_count()? as i64);
 
-        self.recent_releases.gather(self);
+        self.recently_accessed_releases.gather(self);
         self.gather_system_performance();
         Ok(self.registry.gather())
     }
diff --git a/src/web/rustdoc.rs b/src/web/rustdoc.rs
index 1f1e15a6e..8fa2f5736 100644
--- a/src/web/rustdoc.rs
+++ b/src/web/rustdoc.rs
@@ -423,7 +423,9 @@ pub fn rustdoc_html_server_handler(req: &mut Request) -> IronResult<Response> {
         (target, inner_path.join("/"))
     };
 
-    metrics.recent_releases.record(&name, &version, target);
+    metrics
+        .recently_accessed_releases
+        .record(&name, &version, target);
 
     let target = if target == "" {
         String::new()

From 7128e168b1e39097cc601bbc0f76670375441fee Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Mon, 31 Aug 2020 18:53:25 +0200
Subject: [PATCH 05/10] Use database ids to identify crates and versions

---
 src/metrics/mod.rs       | 17 ++++++++---------
 src/web/crate_details.rs |  6 ++++++
 src/web/rustdoc.rs       |  2 +-
 3 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index 5eab89089..62e43e59d 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -79,9 +79,9 @@ metrics! {
 
 #[derive(Debug, Default)]
 pub(crate) struct RecentlyAccessedReleases {
-    krates: DashMap<String, Instant>,
-    versions: DashMap<String, Instant>,
-    platforms: DashMap<String, Instant>,
+    krates: DashMap<i32, Instant>,
+    versions: DashMap<i32, Instant>,
+    platforms: DashMap<(i32, String), Instant>,
 }
 
 impl RecentlyAccessedReleases {
@@ -89,16 +89,15 @@ impl RecentlyAccessedReleases {
         Self::default()
     }
 
-    pub(crate) fn record(&self, krate: &str, version: &str, target: &str) {
-        self.krates.insert(krate.to_owned(), Instant::now());
-        self.versions
-            .insert(format!("{}/{}", krate, version), Instant::now());
+    pub(crate) fn record(&self, krate: i32, version: i32, target: &str) {
+        self.krates.insert(krate, Instant::now());
+        self.versions.insert(version, Instant::now());
         self.platforms
-            .insert(format!("{}/{}/{}", krate, version, target), Instant::now());
+            .insert((version, target.to_owned()), Instant::now());
     }
 
     pub(crate) fn gather(&self, metrics: &Metrics) {
-        fn inner(map: &DashMap<String, Instant>, metric: &IntGaugeVec) {
+        fn inner<K: std::hash::Hash + Eq>(map: &DashMap<K, Instant>, metric: &IntGaugeVec) {
             let mut hour_count = 0;
             let mut half_hour_count = 0;
             let mut five_minute_count = 0;
diff --git a/src/web/crate_details.rs b/src/web/crate_details.rs
index 15cc60ba8..9dfae8930 100644
--- a/src/web/crate_details.rs
+++ b/src/web/crate_details.rs
@@ -45,6 +45,10 @@ pub struct CrateDetails {
     documented_items: Option<f32>,
     total_items_needing_examples: Option<f32>,
     items_with_examples: Option<f32>,
+    /// Database id for this crate
+    pub(crate) crate_id: i32,
+    /// Database id for this release
+    pub(crate) release_id: i32,
 }
 
 fn optional_markdown<S>(markdown: &Option<String>, serializer: S) -> Result<S::Ok, S::Error>
@@ -183,6 +187,8 @@ impl CrateDetails {
             total_items: total_items.map(|v| v as f32),
             total_items_needing_examples: total_items_needing_examples.map(|v| v as f32),
             items_with_examples: items_with_examples.map(|v| v as f32),
+            crate_id,
+            release_id,
         };
 
         if let Some(repository_url) = crate_details.repository_url.clone() {
diff --git a/src/web/rustdoc.rs b/src/web/rustdoc.rs
index 8fa2f5736..54da9e630 100644
--- a/src/web/rustdoc.rs
+++ b/src/web/rustdoc.rs
@@ -425,7 +425,7 @@ pub fn rustdoc_html_server_handler(req: &mut Request) -> IronResult<Response> {
 
     metrics
         .recently_accessed_releases
-        .record(&name, &version, target);
+        .record(krate.crate_id, krate.release_id, target);
 
     let target = if target == "" {
         String::new()

From 7025d02424ef028dd76b5c0fcd39090c0fa0601c Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Mon, 31 Aug 2020 18:53:25 +0200
Subject: [PATCH 06/10] Intern known targets

---
 Cargo.lock         |  2 ++
 Cargo.toml         |  2 ++
 build.rs           | 19 +++++++++++++++++++
 src/lib.rs         |  7 +++++++
 src/metrics/mod.rs |  5 +++--
 5 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 603e10ccb..11536083f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -709,6 +709,8 @@ dependencies = [
  "serde",
  "serde_json",
  "slug",
+ "string_cache",
+ "string_cache_codegen",
  "structopt",
  "strum",
  "systemstat",
diff --git a/Cargo.toml b/Cargo.toml
index 55e97e971..97af2a5da 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,6 +52,7 @@ strum = { version = "0.18.0", features = ["derive"] }
 lol_html = "0.2"
 font-awesome-as-a-crate = { path = "crates/font-awesome-as-a-crate" }
 dashmap = "3.11.10"
+string_cache = "0.8.0"
 
 # Async
 tokio = { version = "0.2.22", features = ["rt-threaded"] }
@@ -98,6 +99,7 @@ rand = "0.7.3"
 time = "0.1"
 git2 = { version = "0.13", default-features = false }
 sass-rs = "0.2.2"
+string_cache_codegen = "0.5.1"
 
 [[bench]]
 name = "html_parsing"
diff --git a/build.rs b/build.rs
index 0e2e5d54d..323e690d9 100644
--- a/build.rs
+++ b/build.rs
@@ -19,6 +19,7 @@ fn main() {
     if let Err(sass_err) = compile_sass() {
         panic!("Error compiling sass: {}", sass_err);
     }
+    write_known_targets().unwrap();
 }
 
 fn write_git_version() {
@@ -87,3 +88,21 @@ fn compile_sass() -> Result<(), Box<dyn Error>> {
 
     Ok(())
 }
+
+fn write_known_targets() -> std::io::Result<()> {
+    use std::io::BufRead;
+
+    let targets: Vec<String> = std::process::Command::new("rustc")
+        .args(&["--print", "target-list"])
+        .output()?
+        .stdout
+        .lines()
+        .filter(|s| s.as_ref().map_or(true, |s| !s.is_empty()))
+        .collect::<std::io::Result<_>>()?;
+
+    string_cache_codegen::AtomType::new("target::TargetAtom", "target_atom!")
+        .atoms(&targets)
+        .write_to_file(&Path::new(&env::var("OUT_DIR").unwrap()).join("target_atom.rs"))?;
+
+    Ok(())
+}
diff --git a/src/lib.rs b/src/lib.rs
index 5c3f06eea..c129cda08 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -26,6 +26,13 @@ mod test;
 pub mod utils;
 mod web;
 
+#[allow(dead_code)]
+mod target {
+    //! [`crate::target::TargetAtom`] is an interned string type for rustc targets, such as
+    //! `x86_64-unknown-linux-gnu`. See the [`string_cache`] docs for usage examples.
+    include!(concat!(env!("OUT_DIR"), "/target_atom.rs"));
+}
+
 use web::page::GlobalAlert;
 
 // Warning message shown in the navigation bar of every page. Set to `None` to hide it.
diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index 62e43e59d..9d7c5e2b3 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -3,6 +3,7 @@ mod macros;
 
 use self::macros::MetricFromOpts;
 use crate::db::Pool;
+use crate::target::TargetAtom;
 use crate::BuildQueue;
 use dashmap::DashMap;
 use failure::Error;
@@ -81,7 +82,7 @@ metrics! {
 pub(crate) struct RecentlyAccessedReleases {
     krates: DashMap<i32, Instant>,
     versions: DashMap<i32, Instant>,
-    platforms: DashMap<(i32, String), Instant>,
+    platforms: DashMap<(i32, TargetAtom), Instant>,
 }
 
 impl RecentlyAccessedReleases {
@@ -93,7 +94,7 @@ impl RecentlyAccessedReleases {
         self.krates.insert(krate, Instant::now());
         self.versions.insert(version, Instant::now());
         self.platforms
-            .insert((version, target.to_owned()), Instant::now());
+            .insert((version, TargetAtom::from(target)), Instant::now());
     }
 
     pub(crate) fn gather(&self, metrics: &Metrics) {

From ee594b051030d759135040c13279f1fcc054e796 Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Tue, 1 Sep 2020 17:59:15 +0200
Subject: [PATCH 07/10] s/krates/crates

---
 src/metrics/mod.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index 9d7c5e2b3..006b8cc87 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -80,7 +80,7 @@ metrics! {
 
 #[derive(Debug, Default)]
 pub(crate) struct RecentlyAccessedReleases {
-    krates: DashMap<i32, Instant>,
+    crates: DashMap<i32, Instant>,
     versions: DashMap<i32, Instant>,
     platforms: DashMap<(i32, TargetAtom), Instant>,
 }
@@ -91,7 +91,7 @@ impl RecentlyAccessedReleases {
     }
 
     pub(crate) fn record(&self, krate: i32, version: i32, target: &str) {
-        self.krates.insert(krate, Instant::now());
+        self.crates.insert(krate, Instant::now());
         self.versions.insert(version, Instant::now());
         self.platforms
             .insert((version, TargetAtom::from(target)), Instant::now());
@@ -130,7 +130,7 @@ impl RecentlyAccessedReleases {
                 .set(five_minute_count);
         }
 
-        inner(&self.krates, &metrics.recent_crates);
+        inner(&self.crates, &metrics.recent_crates);
         inner(&self.versions, &metrics.recent_versions);
         inner(&self.platforms, &metrics.recent_platforms);
     }

From 770a3ef0d7e492a4e2b6101f37ba4356b95c940b Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Tue, 1 Sep 2020 18:01:45 +0200
Subject: [PATCH 08/10] Rearrange recently accessed crate checks for
 readability

---
 src/metrics/mod.rs | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index 006b8cc87..5eb9e453a 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -104,19 +104,19 @@ impl RecentlyAccessedReleases {
             let mut five_minute_count = 0;
             map.retain(|_, instant| {
                 let elapsed = instant.elapsed();
-                if elapsed > Duration::from_secs(60 * 60) {
-                    return false;
+
+                if elapsed < Duration::from_secs(60 * 60) {
+                    hour_count += 1;
                 }
-                hour_count += 1;
-                if elapsed > Duration::from_secs(30 * 60) {
-                    return true;
+                if elapsed < Duration::from_secs(30 * 60) {
+                    half_hour_count += 1;
                 }
-                half_hour_count += 1;
-                if elapsed > Duration::from_secs(5 * 60) {
-                    return true;
+                if elapsed < Duration::from_secs(5 * 60) {
+                    five_minute_count += 1;
                 }
-                five_minute_count += 1;
-                true
+
+                // Only retain items accessed within the last hour
+                return elapsed < Duration::from_secs(60 * 60);
             });
 
             metric.with_label_values(&["one hour"]).set(hour_count);

From 34c1f5b7906bbdfd42369ca209262740e332727d Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Fri, 11 Sep 2020 19:12:52 +0200
Subject: [PATCH 09/10] Review nits

---
 src/metrics/mod.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index 5eb9e453a..68e014988 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -91,10 +91,11 @@ impl RecentlyAccessedReleases {
     }
 
     pub(crate) fn record(&self, krate: i32, version: i32, target: &str) {
-        self.crates.insert(krate, Instant::now());
-        self.versions.insert(version, Instant::now());
+        let now = Instant::now();
+        self.crates.insert(krate, now);
+        self.versions.insert(version, now);
         self.platforms
-            .insert((version, TargetAtom::from(target)), Instant::now());
+            .insert((version, TargetAtom::from(target)), now);
     }
 
     pub(crate) fn gather(&self, metrics: &Metrics) {
@@ -116,7 +117,7 @@ impl RecentlyAccessedReleases {
                 }
 
                 // Only retain items accessed within the last hour
-                return elapsed < Duration::from_secs(60 * 60);
+                elapsed < Duration::from_secs(60 * 60)
             });
 
             metric.with_label_values(&["one hour"]).set(hour_count);

From 22ae1da4449038c52e25f494456c45bb18acde7a Mon Sep 17 00:00:00 2001
From: Wim Looman <git@nemo157.com>
Date: Fri, 11 Sep 2020 19:16:38 +0200
Subject: [PATCH 10/10] Add an upper limit to number of recently accessed
 releases that will be tracked

---
 src/metrics/mod.rs | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/metrics/mod.rs b/src/metrics/mod.rs
index 68e014988..f5142035e 100644
--- a/src/metrics/mod.rs
+++ b/src/metrics/mod.rs
@@ -91,6 +91,11 @@ impl RecentlyAccessedReleases {
     }
 
     pub(crate) fn record(&self, krate: i32, version: i32, target: &str) {
+        if self.platforms.len() > 100_000 {
+            // Avoid filling the maps _too_ much, we should never get anywhere near this limit
+            return;
+        }
+
         let now = Instant::now();
         self.crates.insert(krate, now);
         self.versions.insert(version, now);