4 files changed, 249 insertions, 13 deletions

diff --git a/xtask/src/dist.rs b/xtask/src/dist.rs
index c198c0907..01d903cde 100644
--- a/xtask/src/dist.rs
+++ b/xtask/src/dist.rs
@@ -13,17 +13,24 @@ use crate::{
     project_root,
 };
 
-pub fn run_dist(nightly: bool, client_version: Option<String>) -> Result<()> {
-    let dist = project_root().join("dist");
-    rm_rf(&dist)?;
-    fs2::create_dir_all(&dist)?;
-
-    if let Some(version) = client_version {
-        let release_tag = if nightly { "nightly".to_string() } else { date_iso()? };
-        dist_client(&version, &release_tag)?;
+pub struct DistCmd {
+    pub nightly: bool,
+    pub client_version: Option<String>,
+}
+
+impl DistCmd {
+    pub fn run(self) -> Result<()> {
+        let dist = project_root().join("dist");
+        rm_rf(&dist)?;
+        fs2::create_dir_all(&dist)?;
+
+        if let Some(version) = self.client_version {
+            let release_tag = if self.nightly { "nightly".to_string() } else { date_iso()? };
+            dist_client(&version, &release_tag)?;
+        }
+        dist_server()?;
+        Ok(())
     }
-    dist_server()?;
-    Ok(())
 }
 
 fn dist_client(version: &str, release_tag: &str) -> Result<()> {
diff --git a/xtask/src/lib.rs b/xtask/src/lib.rs
index 94d451e23..2fdb08f2e 100644
--- a/xtask/src/lib.rs
+++ b/xtask/src/lib.rs
@@ -7,6 +7,7 @@ pub mod install;
 pub mod release;
 pub mod dist;
 pub mod pre_commit;
+pub mod metrics;
 
 pub mod codegen;
 mod ast_src;
diff --git a/xtask/src/main.rs b/xtask/src/main.rs
index 53d3ce3e7..604954269 100644
--- a/xtask/src/main.rs
+++ b/xtask/src/main.rs
@@ -13,8 +13,9 @@ use std::env;
 use pico_args::Arguments;
 use xtask::{
     codegen::{self, Mode},
-    dist::run_dist,
+    dist::DistCmd,
     install::{ClientOpt, InstallCmd, Malloc, ServerOpt},
+    metrics::run_metrics,
     not_bash::pushd,
     pre_commit, project_root,
     release::{PromoteCmd, ReleaseCmd},
@@ -115,8 +116,9 @@ FLAGS:
             let nightly = args.contains("--nightly");
             let client_version: Option<String> = args.opt_value_from_str("--client")?;
             args.finish()?;
-            run_dist(nightly, client_version)
+            DistCmd { nightly, client_version }.run()
         }
+        "metrics" => run_metrics(),
         _ => {
             eprintln!(
                 "\
@@ -133,7 +135,8 @@ SUBCOMMANDS:
     codegen
     install
     lint
-    dist"
+    dist
+    promote"
             );
             Ok(())
         }
diff --git a/xtask/src/metrics.rs b/xtask/src/metrics.rs
new file mode 100644
index 000000000..9567f18f0
--- /dev/null
+++ b/xtask/src/metrics.rs
@@ -0,0 +1,225 @@
+use std::{
+    collections::BTreeMap,
+    env,
+    fmt::{self, Write as _},
+    io::Write as _,
+    time::{Instant, SystemTime, UNIX_EPOCH},
+};
+
+use anyhow::{bail, format_err, Result};
+
+use crate::not_bash::{fs2, pushd, rm_rf, run};
+
+type Unit = &'static str;
+
+pub fn run_metrics() -> Result<()> {
+    let mut metrics = Metrics::new()?;
+    metrics.measure_build()?;
+
+    {
+        let _d = pushd("target");
+        let metrics_token = env::var("METRICS_TOKEN").unwrap();
+        let repo = format!("https://{}@github.com/rust-analyzer/metrics.git", metrics_token);
+        run!("git clone --depth 1 {}", repo)?;
+        let _d = pushd("metrics");
+
+        let mut file = std::fs::OpenOptions::new().append(true).open("metrics.json")?;
+        writeln!(file, "{}", metrics.json())?;
+        run!("git add .")?;
+        run!("git -c user.name=Bot -c [email protected] commit --message 📈")?;
+        run!("git push origin master")?;
+    }
+    eprintln!("{:#?}", metrics);
+    Ok(())
+}
+
+impl Metrics {
+    fn measure_build(&mut self) -> Result<()> {
+        run!("cargo fetch")?;
+        rm_rf("./target/release")?;
+
+        let build = Instant::now();
+        run!("cargo build --release --package rust-analyzer --bin rust-analyzer")?;
+        let build = build.elapsed();
+        self.report("build", build.as_millis() as u64, "ms");
+        Ok(())
+    }
+}
+
+#[derive(Debug)]
+struct Metrics {
+    host: Host,
+    timestamp: SystemTime,
+    revision: String,
+    metrics: BTreeMap<String, (u64, Unit)>,
+}
+
+#[derive(Debug)]
+struct Host {
+    os: String,
+    cpu: String,
+    mem: String,
+}
+
+impl Metrics {
+    fn new() -> Result<Metrics> {
+        let host = Host::new()?;
+        let timestamp = SystemTime::now();
+        let revision = run!("git rev-parse HEAD")?;
+        Ok(Metrics { host, timestamp, revision, metrics: BTreeMap::new() })
+    }
+
+    fn report(&mut self, name: &str, value: u64, unit: Unit) {
+        self.metrics.insert(name.into(), (value, unit));
+    }
+
+    fn json(&self) -> Json {
+        let mut json = Json::default();
+        self.to_json(&mut json);
+        json
+    }
+    fn to_json(&self, json: &mut Json) {
+        json.begin_object();
+        {
+            json.field("host");
+            self.host.to_json(json);
+
+            json.field("timestamp");
+            let timestamp = self.timestamp.duration_since(UNIX_EPOCH).unwrap();
+            json.number(timestamp.as_secs() as f64);
+
+            json.field("revision");
+            json.string(&self.revision);
+
+            json.field("metrics");
+            json.begin_object();
+            {
+                for (k, &(value, unit)) in &self.metrics {
+                    json.field(k);
+                    json.begin_array();
+                    {
+                        json.number(value as f64);
+                        json.string(unit);
+                    }
+                    json.end_array();
+                }
+            }
+            json.end_object()
+        }
+        json.end_object();
+    }
+}
+
+impl Host {
+    fn new() -> Result<Host> {
+        if cfg!(not(target_os = "linux")) {
+            bail!("can only collect metrics on Linux ");
+        }
+
+        let os = read_field("/etc/os-release", "PRETTY_NAME=")?.trim_matches('"').to_string();
+
+        let cpu =
+            read_field("/proc/cpuinfo", "model name")?.trim_start_matches(':').trim().to_string();
+
+        let mem = read_field("/proc/meminfo", "MemTotal:")?;
+
+        return Ok(Host { os, cpu, mem });
+
+        fn read_field<'a>(path: &str, field: &str) -> Result<String> {
+            let text = fs2::read_to_string(path)?;
+
+            let line = text
+                .lines()
+                .find(|it| it.starts_with(field))
+                .ok_or_else(|| format_err!("can't parse {}", path))?;
+            Ok(line[field.len()..].trim().to_string())
+        }
+    }
+    fn to_json(&self, json: &mut Json) {
+        json.begin_object();
+        {
+            json.field("os");
+            json.string(&self.os);
+
+            json.field("cpu");
+            json.string(&self.cpu);
+
+            json.field("mem");
+            json.string(&self.mem);
+        }
+        json.end_object();
+    }
+}
+
+struct State {
+    obj: bool,
+    first: bool,
+}
+
+#[derive(Default)]
+struct Json {
+    stack: Vec<State>,
+    buf: String,
+}
+
+impl Json {
+    fn begin_object(&mut self) {
+        self.stack.push(State { obj: true, first: true });
+        self.buf.push('{');
+    }
+    fn end_object(&mut self) {
+        self.stack.pop();
+        self.buf.push('}')
+    }
+    fn begin_array(&mut self) {
+        self.stack.push(State { obj: false, first: true });
+        self.buf.push('[');
+    }
+    fn end_array(&mut self) {
+        self.stack.pop();
+        self.buf.push(']')
+    }
+    fn field(&mut self, name: &str) {
+        self.object_comma();
+        self.string_token(name);
+        self.buf.push(':');
+    }
+    fn string(&mut self, value: &str) {
+        self.array_comma();
+        self.string_token(value);
+    }
+    fn string_token(&mut self, value: &str) {
+        self.buf.push('"');
+        self.buf.extend(value.escape_default());
+        self.buf.push('"');
+    }
+    fn number(&mut self, value: f64) {
+        self.array_comma();
+        write!(self.buf, "{}", value).unwrap();
+    }
+
+    fn array_comma(&mut self) {
+        let state = self.stack.last_mut().unwrap();
+        if state.obj {
+            return;
+        }
+        if !state.first {
+            self.buf.push(',');
+        }
+        state.first = false;
+    }
+
+    fn object_comma(&mut self) {
+        let state = self.stack.last_mut().unwrap();
+        if !state.first {
+            self.buf.push(',');
+        }
+        state.first = false;
+    }
+}
+
+impl fmt::Display for Json {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.buf)
+    }
+}