feat(build-analysis): build-started log message

The build-started message ought to be pretty much the same
as the header in timings HTML report,
but some data is only available
after the entire build or dependency resolution.
Let's collect these data first.

Author: weihanglo

src/cargo/ops/cargo_compile/mod.rs

@@ -56,6 +56,7 @@ use crate::ops::resolve::{SpecsAndResolvedFeatures, WorkspaceResolve};
 use crate::util::BuildLogger;
 use crate::util::context::{GlobalContext, WarningHandling};
 use crate::util::interning::InternedString;
+use crate::util::log_message::LogMessage;
 use crate::util::{CargoResult, StableHasher};
 
 mod compile_filter;
@@ -155,9 +156,24 @@ pub fn compile_ws<'a>(
     exec: &Arc<dyn Executor>,
 ) -> CargoResult<Compilation<'a>> {
     let interner = UnitInterner::new();
-    let _logger = BuildLogger::maybe_new(ws)?;
+    let logger = BuildLogger::maybe_new(ws)?;
+
+    if let Some(ref logger) = logger {
+        let rustc = ws.gctx().load_global_rustc(Some(ws))?;
+        logger.log(&LogMessage::BuildStarted {
+            cwd: ws.gctx().cwd(),
+            host: rustc.host.as_str(),
+            jobs: options.build_config.jobs,
+            profile: options.build_config.requested_profile.as_str(),
+            rustc_version: &rustc.version.to_string(),
+            rustc_version_verbose: &rustc.verbose_version,
+            target_dir: &ws.target_dir().as_path_unlocked(),
+            workspace_root: &ws.root(),
+        });
+    }
 
     let bcx = create_bcx(ws, options, &interner)?;
+
     if options.build_config.unit_graph {
         unit_graph::emit_serialized_unit_graph(&bcx.roots, &bcx.unit_graph, ws.gctx())?;
         return Compilation::new(&bcx);

src/cargo/util/log_message.rs

@@ -1,5 +1,7 @@
 //! Messages for logging.
 
+use std::path::Path;
+
 use jiff::Timestamp;
 use serde::Serialize;
 
@@ -8,17 +10,29 @@ use serde::Serialize;
 /// Each variant represents a different type of event.
 #[derive(Serialize)]
 #[serde(tag = "reason", rename_all = "kebab-case")]
-pub enum LogMessage {}
+pub enum LogMessage<'a> {
+    /// Emitted when a build starts.
+    BuildStarted {
+        cwd: &'a Path,
+        host: &'a str,
+        jobs: u32,
+        profile: &'a str,
+        rustc_version: &'a str,
+        rustc_version_verbose: &'a str,
+        target_dir: &'a Path,
+        workspace_root: &'a Path,
+    },
+}
 
-impl LogMessage {
+impl LogMessage<'_> {
     /// Converts this message to a JSON log line with run_id and timestamp.
     pub fn to_json_log(&self, run_id: &str) -> String {
         #[derive(Serialize)]
         struct LogEntry<'a> {
             run_id: &'a str,
             timestamp: Timestamp,
             #[serde(flatten)]
-            msg: &'a LogMessage,
+            msg: &'a LogMessage<'a>,
         }
 
         let entry = LogEntry {

src/cargo/util/logger.rs

@@ -85,7 +85,7 @@ impl BuildLogger {
     }
 
     /// Logs a message.
-    pub fn log(&self, msg: &LogMessage) {
+    pub fn log(&self, msg: &LogMessage<'_>) {
         let json = msg.to_json_log(&self.run_id);
         let _ = self.tx.send(json);
     }

tests/testsuite/build_analysis.rs

@@ -3,6 +3,8 @@
 use crate::prelude::*;
 
 use cargo_test_support::basic_manifest;
+use cargo_test_support::compare::assert_e2e;
+use cargo_test_support::paths;
 use cargo_test_support::project;
 use cargo_test_support::str;
 
@@ -42,3 +44,51 @@ fn simple() {
 "#]])
         .run();
 }
+
+#[cargo_test]
+fn log_msg_build_started() {
+    let p = project()
+        .file("Cargo.toml", &basic_manifest("foo", "0.0.0"))
+        .file("src/lib.rs", "")
+        .build();
+
+    p.cargo("check -Zbuild-analysis")
+        .env("CARGO_BUILD_ANALYSIS_ENABLED", "true")
+        .masquerade_as_nightly_cargo(&["build-analysis"])
+        .run();
+
+    let cargo_home = paths::cargo_home();
+    let log_dir = cargo_home.join("log");
+    assert!(log_dir.exists());
+
+    let entries = std::fs::read_dir(&log_dir).unwrap();
+    let log_file = entries
+        .filter_map(Result::ok)
+        .find(|e| e.path().extension().and_then(|s| s.to_str()) == Some("jsonl"))
+        .unwrap();
+
+    let content = std::fs::read_to_string(log_file.path()).unwrap();
+
+    assert_e2e().eq(
+        &content,
+        str![[r#"
+[
+  {
+    "cwd": "[ROOT]/foo",
+    "host": "[HOST_TARGET]",
+    "jobs": "{...}",
+    "profile": "dev",
+    "reason": "build-started",
+    "run_id": "[..]T[..]Z-[..]",
+    "rustc_version": "1.[..]",
+    "rustc_version_verbose": "{...}",
+    "target_dir": "[ROOT]/foo/target",
+    "timestamp": "[..]T[..]Z",
+    "workspace_root": "[ROOT]/foo"
+  }
+]
+"#]]
+        .is_json()
+        .against_jsonlines(),
+    );
+}