show average build durations in build lists, crate details

crates/bin/docs_rs_web/Cargo.toml

@@ -99,4 +99,3 @@ opentelemetry_sdk = { workspace = true }
 pretty_assertions = { workspace = true }
 test-case = { workspace = true }
 walkdir = { workspace = true }
-

crates/bin/docs_rs_web/src/handlers/builds.rs

@@ -21,7 +21,7 @@ use docs_rs_build_limits::Limits;
 use docs_rs_build_queue::{AsyncBuildQueue, PRIORITY_MANUAL_FROM_CRATES_IO};
 use docs_rs_context::Context;
 use docs_rs_headers::CanonicalUrl;
-use docs_rs_types::{BuildId, BuildStatus, KrateName, ReqVersion, Version};
+use docs_rs_types::{BuildId, BuildStatus, Duration, KrateName, ReqVersion, Version};
 use http::StatusCode;
 use std::sync::Arc;
 
@@ -32,6 +32,7 @@ pub(crate) struct Build {
     docsrs_version: Option<String>,
     build_status: BuildStatus,
     build_time: Option<DateTime<Utc>>,
+    build_duration: Option<Duration>,
     errors: Option<String>,
 }
 
@@ -195,8 +196,10 @@ async fn get_builds(
             builds.docsrs_version,
             builds.build_status as "build_status: BuildStatus",
             COALESCE(builds.build_finished, builds.build_started) as build_time,
+            durations.duration AS "build_duration?: Duration",
             builds.errors
          FROM builds
+         INNER JOIN build_durations AS durations ON durations.build_id = builds.id
          INNER JOIN releases ON releases.id = builds.rid
          INNER JOIN crates ON releases.crate_id = crates.id
          WHERE
@@ -530,14 +533,14 @@ mod tests {
             };
             Overrides::save(&mut conn, &FOO, limits).await?;
 
-            let page = kuchikiki::parse_html().one(
+            let page = kuchikiki::parse_html().one(dbg!(
                 env.web_app()
                     .await
-                    .get(&format!("/crate/foo/{V1}/builds"))
+                    .assert_success(&format!("/crate/foo/{V1}/builds"))
                     .await?
                     .text()
-                    .await?,
-            );
+                    .await?
+            ));
 
             let header = page.select(".about h4").unwrap().next().unwrap();
             assert_eq!(header.text_contents(), "foo's sandbox limits");
@@ -550,7 +553,7 @@ mod tests {
             let values: Vec<_> = values.iter().map(|v| &**v).collect();
 
             assert!(values.contains(&"6.44 GB"));
-            assert!(values.contains(&"2 hours"));
+            assert!(values.contains(&"2h"));
             assert!(values.contains(&"102.4 kB"));
             assert!(values.contains(&"blocked"));
             assert!(values.contains(&"1"));

crates/bin/docs_rs_web/src/handlers/crate_details.rs

@@ -23,7 +23,9 @@ use docs_rs_database::crate_details::{Release, latest_release, parse_doc_targets
 use docs_rs_headers::CanonicalUrl;
 use docs_rs_registry_api::OwnerKind;
 use docs_rs_storage::{AsyncStorage, PathNotFoundError};
-use docs_rs_types::{BuildId, BuildStatus, CrateId, KrateName, ReleaseId, ReqVersion, Version};
+use docs_rs_types::{
+    BuildId, BuildStatus, CrateId, Duration, KrateName, ReleaseId, ReqVersion, Version,
+};
 use futures_util::stream::TryStreamExt;
 use serde_json::Value;
 use std::sync::Arc;
@@ -342,6 +344,40 @@ impl CrateDetails {
     }
 }
 
+#[derive(Debug, Clone, Default)]
+struct BuildStatistics {
+    avg_build_duration_release: Option<Duration>,
+    avg_build_duration_crate: Option<Duration>,
+}
+
+impl BuildStatistics {
+    fn has_data(&self) -> bool {
+        self.avg_build_duration_crate.is_some() || self.avg_build_duration_release.is_some()
+    }
+
+    async fn fetch_for_release(
+        conn: &mut sqlx::PgConnection,
+        release_id: ReleaseId,
+    ) -> Result<Self> {
+        Ok(sqlx::query_as!(
+            BuildStatistics,
+            r#"
+            SELECT
+                dr.avg_duration AS "avg_build_duration_release?: Duration",
+                dc.avg_duration AS "avg_build_duration_crate?: Duration"
+            FROM
+                build_durations_release AS dr
+            INNER JOIN build_durations_crate AS dc on dr.crate_id = dc.crate_id
+            WHERE rid = $1
+            "#,
+            release_id as _,
+        )
+        .fetch_optional(conn)
+        .await?
+        .unwrap_or_default())
+    }
+}
+
 #[derive(Debug, Clone, Template)]
 #[template(path = "crate/details.html")]
 struct CrateDetailsPage {
@@ -352,6 +388,7 @@ struct CrateDetailsPage {
     documented_items: Option<i32>,
     total_items: Option<i32>,
     total_items_needing_examples: Option<i32>,
+    build_statistics: BuildStatistics,
     items_with_examples: Option<i32>,
     homepage_url: Option<String>,
     documentation_url: Option<String>,
@@ -418,6 +455,9 @@ pub(crate) async fn crate_details_handler(
         Err(e) => warn!(?e, "error fetching readme"),
     }
 
+    let build_statistics =
+        BuildStatistics::fetch_for_release(&mut conn, details.release_id).await?;
+
     let CrateDetails {
         version,
         name,
@@ -454,6 +494,7 @@ pub(crate) async fn crate_details_handler(
         documented_items,
         total_items,
         total_items_needing_examples,
+        build_statistics,
         items_with_examples,
         homepage_url,
         documentation_url,
@@ -644,6 +685,7 @@ mod tests {
     use docs_rs_registry_api::CrateOwner;
     use docs_rs_test_fakes::{FakeBuild, fake_release_that_failed_before_build};
     use docs_rs_types::KrateName;
+    use docs_rs_types::testing::{FOO, V1};
     use http::StatusCode;
     use kuchikiki::traits::TendrilSink;
     use pretty_assertions::assert_eq;
@@ -2311,4 +2353,45 @@ path = "src/lib.rs"
             Ok(())
         });
     }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_build_stats_no_data() -> Result<()> {
+        let env = TestEnvironment::new().await?;
+        let mut conn = env.async_conn().await?;
+
+        let stats = BuildStatistics::fetch_for_release(&mut conn, ReleaseId(42)).await?;
+        assert!(!stats.has_data());
+        assert!(stats.avg_build_duration_release.is_none());
+        assert!(stats.avg_build_duration_crate.is_none());
+
+        Ok(())
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_build_stats_with_build() -> Result<()> {
+        let env = TestEnvironment::new().await?;
+
+        let rid = env
+            .fake_release()
+            .await
+            .name(&FOO)
+            .version(V1)
+            .create()
+            .await?;
+
+        let mut conn = env.async_conn().await?;
+
+        let stats = BuildStatistics::fetch_for_release(&mut conn, rid).await?;
+        assert!(stats.has_data());
+        assert!(stats.avg_build_duration_release.is_some());
+        assert!(stats.avg_build_duration_crate.is_some());
+
+        assert!(
+            !BuildStatistics::fetch_for_release(&mut conn, ReleaseId(42))
+                .await?
+                .has_data()
+        );
+
+        Ok(())
+    }
 }