1use client::ZED_APP_VERSION;
 2use gpui::{platform::AppVersion, AppContext};
 3use human_bytes::human_bytes;
 4use serde::Serialize;
 5use std::{env, fmt::Display};
 6use sysinfo::{System, SystemExt};
 7use util::channel::ReleaseChannel;
 8
 9// TODO: Move this file out of feedback and into a more general place
10
11#[derive(Clone, Debug, Serialize)]
12pub struct SystemSpecs {
13    #[serde(serialize_with = "serialize_app_version")]
14    app_version: Option<AppVersion>,
15    release_channel: &'static str,
16    os_name: &'static str,
17    os_version: Option<String>,
18    memory: u64,
19    architecture: &'static str,
20}
21
22impl SystemSpecs {
23    pub fn new(cx: &AppContext) -> Self {
24        let platform = cx.platform();
25        let app_version = ZED_APP_VERSION.or_else(|| platform.app_version().ok());
26        let release_channel = cx.global::<ReleaseChannel>().dev_name();
27        let os_name = platform.os_name();
28        let system = System::new_all();
29        let memory = system.total_memory();
30        let architecture = env::consts::ARCH;
31        let os_version = platform
32            .os_version()
33            .ok()
34            .map(|os_version| os_version.to_string());
35
36        SystemSpecs {
37            app_version,
38            release_channel,
39            os_name,
40            os_version,
41            memory,
42            architecture,
43        }
44    }
45}
46
47impl Display for SystemSpecs {
48    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
49        let os_information = match &self.os_version {
50            Some(os_version) => format!("OS: {} {}", self.os_name, os_version),
51            None => format!("OS: {}", self.os_name),
52        };
53        let app_version_information = self
54            .app_version
55            .as_ref()
56            .map(|app_version| format!("Zed: v{} ({})", app_version, self.release_channel));
57        let system_specs = [
58            app_version_information,
59            Some(os_information),
60            Some(format!("Memory: {}", human_bytes(self.memory as f64))),
61            Some(format!("Architecture: {}", self.architecture)),
62        ]
63        .into_iter()
64        .flatten()
65        .collect::<Vec<String>>()
66        .join("\n");
67
68        write!(f, "{system_specs}")
69    }
70}
71
72fn serialize_app_version<S>(version: &Option<AppVersion>, serializer: S) -> Result<S::Ok, S::Error>
73where
74    S: serde::Serializer,
75{
76    version.map(|v| v.to_string()).serialize(serializer)
77}