Add metrics tracking number of recently loaded crates/versions/platforms

Author: Nemo157

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,

src/metrics/mod.rs

@@ -1,6 +1,7 @@
 #[macro_use]
 mod macros;
 
+use std::{time::{Duration, Instant}, collections::HashMap, sync::Mutex};
 use self::macros::MetricFromOpts;
 use crate::db::Pool;
 use crate::BuildQueue;
@@ -10,6 +11,7 @@ use prometheus::proto::MetricFamily;
 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 +46,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 +76,69 @@ 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 +154,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())
     }

src/web/metrics.rs

@@ -35,6 +35,7 @@ pub struct RequestRecorder {
     route_name: String,
 }
 
+
 impl RequestRecorder {
     pub fn new(handler: impl iron::Handler, route: impl Into<String>) -> Self {
         Self {

src/web/rustdoc.rs

@@ -389,6 +389,8 @@ pub fn rustdoc_html_server_handler(req: &mut Request) -> IronResult<Response> {
         format!("/crate/{}/{}", name, latest_version)
     };
 
+    let mut target = "";
+
     // The path within this crate version's rustdoc output
     let inner_path = {
         let mut inner_path = req_path.clone();
@@ -397,12 +399,14 @@ pub fn rustdoc_html_server_handler(req: &mut Request) -> IronResult<Response> {
         inner_path.drain(..3).for_each(drop);
 
         if inner_path.len() > 1 && krate.doc_targets.iter().any(|s| s == inner_path[0]) {
-            inner_path.remove(0);
+            target = inner_path.remove(0);
         }
 
         inner_path.join("/")
     };
 
+    metrics.recent_releases.record(&name, &version, target);
+
     rendering_time.step("rewrite html");
     RustdocPage {
         latest_path,