store date of nightly version in separate field

migrations/20241018052241_builds-rustc-nightly-date.down.sql

@@ -0,0 +1,4 @@
+DROP INDEX builds_nightly_date_idx;
+
+ALTER TABLE builds 
+    DROP COLUMN rustc_nightly_date;

migrations/20241018052241_builds-rustc-nightly-date.up.sql

@@ -0,0 +1,8 @@
+ALTER TABLE builds 
+    ADD COLUMN rustc_nightly_date DATE;
+
+CREATE INDEX builds_nightly_date_idx ON builds USING btree (rustc_nightly_date);
+
+UPDATE builds 
+    SET rustc_nightly_date = CAST(SUBSTRING(rustc_version FROM ' (\d+-\d+-\d+)\)$') AS DATE)
+    WHERE rustc_version IS NOT NULL;

src/db/add_package.rs

@@ -4,7 +4,7 @@ use crate::{
     error::Result,
     registry_api::{CrateData, CrateOwner, ReleaseData},
     storage::CompressionAlgorithm,
-    utils::MetadataPackage,
+    utils::{rustc_version::parse_rustc_date, MetadataPackage},
     web::crate_details::{latest_release, releases_for_crate},
 };
 use anyhow::Context;
@@ -17,7 +17,7 @@ use std::{
     io::{BufRead, BufReader},
     path::Path,
 };
-use tracing::{debug, info, instrument};
+use tracing::{debug, error, info, instrument};
 
 /// Adds a package into database.
 ///
@@ -248,6 +248,20 @@ pub(crate) async fn finish_build(
     debug!("updating build after finishing");
     let hostname = hostname::get()?;
 
+    let rustc_date = match parse_rustc_date(rustc_version) {
+        Ok(date) => Some(date),
+        Err(err) => {
+            // in the database we see cases where the rustc version is missing
+            // in the builds-table. In this case & if we can't parse the version
+            // we just want to log an error, but still finish the build.
+            error!(
+                "Failed to parse date from rustc version \"{}\": {:?}",
+                rustc_version, err
+            );
+            None
+        }
+    };
+
     let release_id = sqlx::query_scalar!(
         "UPDATE builds
          SET
@@ -257,16 +271,18 @@ pub(crate) async fn finish_build(
              build_server = $4,
              errors = $5,
              documentation_size = $6,
+             rustc_nightly_date = $7,
              build_finished = NOW()
          WHERE
-            id = $7
+            id = $8
          RETURNING rid",
         rustc_version,
         docsrs_version,
         build_status as BuildStatus,
         hostname.to_str().unwrap_or(""),
         errors,
         documentation_size.map(|v| v as i64),
+        rustc_date,
         build_id,
     )
     .fetch_one(&mut *conn)
@@ -612,6 +628,7 @@ mod test {
     use crate::registry_api::OwnerKind;
     use crate::test::*;
     use crate::utils::CargoMetadata;
+    use chrono::NaiveDate;
     use test_case::test_case;
 
     #[test]
@@ -649,7 +666,56 @@ mod test {
     }
 
     #[test]
-    fn test_finish_build_success() {
+    fn test_finish_build_success_valid_rustc_date() {
+        async_wrapper(|env| async move {
+            let mut conn = env.async_db().await.async_conn().await;
+            let crate_id = initialize_crate(&mut conn, "krate").await?;
+            let release_id = initialize_release(&mut conn, crate_id, "0.1.0").await?;
+            let build_id = initialize_build(&mut conn, release_id).await?;
+
+            finish_build(
+                &mut conn,
+                build_id,
+                "rustc 1.84.0-nightly (e7c0d2750 2024-10-15)",
+                "docsrs_version",
+                BuildStatus::Success,
+                None,
+                None,
+            )
+            .await?;
+
+            let row = sqlx::query!(
+                r#"SELECT
+                rustc_version,
+                docsrs_version,
+                build_status as "build_status: BuildStatus",
+                errors,
+                rustc_nightly_date
+                FROM builds
+                WHERE id = $1"#,
+                build_id
+            )
+            .fetch_one(&mut *conn)
+            .await?;
+
+            assert_eq!(
+                row.rustc_version,
+                Some("rustc 1.84.0-nightly (e7c0d2750 2024-10-15)".into())
+            );
+            assert_eq!(row.docsrs_version, Some("docsrs_version".into()));
+            assert_eq!(row.build_status, BuildStatus::Success);
+            assert_eq!(
+                row.rustc_nightly_date,
+                Some(NaiveDate::from_ymd_opt(2024, 10, 15).unwrap())
+            );
+            assert!(row.errors.is_none());
+
+            Ok(())
+        })
+    }
+
+    #[test]
+    fn test_finish_build_success_invalid_rustc_date() {
         async_wrapper(|env| async move {
             let mut conn = env.async_db().await.async_conn().await;
             let crate_id = initialize_crate(&mut conn, "krate").await?;
@@ -673,7 +739,8 @@ mod test {
                 docsrs_version,
                 build_status as "build_status: BuildStatus",
                 documentation_size,
-                errors
+                errors,
+                rustc_nightly_date
                 FROM builds
                 WHERE id = $1"#,
                 build_id
@@ -685,6 +752,7 @@ mod test {
             assert_eq!(row.docsrs_version, Some("docsrs_version".into()));
             assert_eq!(row.build_status, BuildStatus::Success);
             assert_eq!(row.documentation_size, Some(42));
+            assert!(row.rustc_nightly_date.is_none());
             assert!(row.errors.is_none());
 
             Ok(())

src/utils/mod.rs

@@ -21,7 +21,7 @@ pub mod daemon;
 mod html;
 mod queue;
 pub(crate) mod queue_builder;
-mod rustc_version;
+pub(crate) mod rustc_version;
 use anyhow::Result;
 use serde::de::DeserializeOwned;
 use serde::Serialize;

src/utils/rustc_version.rs

@@ -21,7 +21,7 @@ pub fn parse_rustc_version<S: AsRef<str>>(version: S) -> Result<String> {
     ))
 }
 
-fn parse_rustc_date<S: AsRef<str>>(version: S) -> Result<NaiveDate> {
+pub(crate) fn parse_rustc_date<S: AsRef<str>>(version: S) -> Result<NaiveDate> {
     static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r" (\d+)-(\d+)-(\d+)\)$").unwrap());
 
     let cap = RE