Pull app / OS info out of GPUI, add Linux information, make fallible window initialization (#12869)

TODO:
- [x] Finish GPUI changes on other operating systems 

This is a largely internal change to how we report data to our
diagnostics and telemetry. This PR also includes an update to our blade
backend which allows us to report errors in a more useful way when
failing to initialize blade.


Release Notes:

- N/A

---------

Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>

crates/client/Cargo.toml

@@ -24,6 +24,7 @@ chrono = { workspace = true, features = ["serde"] }
 clock.workspace = true
 collections.workspace = true
 feature_flags.workspace = true
+fs.workspace = true
 futures.workspace = true
 gpui.workspace = true
 http.workspace = true
@@ -60,6 +61,12 @@ settings = { workspace = true, features = ["test-support"] }
 util = { workspace = true, features = ["test-support"] }
 http = { workspace = true, features = ["test-support"] }
 
+[target.'cfg(target_os = "windows")'.dependencies]
+windows.workspace = true
+
+[target.'cfg(target_os = "macos")'.dependencies]
+cocoa.workspace = true
+
 [target.'cfg(target_os = "linux")'.dependencies]
 async-native-tls = {"version" = "0.5.0", features = ["vendored"]}
 # This is an indirect dependency of async-tungstenite that is included

crates/client/src/telemetry.rs

@@ -4,7 +4,7 @@ use crate::{ChannelId, TelemetrySettings};
 use chrono::{DateTime, Utc};
 use clock::SystemClock;
 use futures::Future;
-use gpui::{AppContext, AppMetadata, BackgroundExecutor, Task};
+use gpui::{AppContext, BackgroundExecutor, Task};
 use http::{self, HttpClient, HttpClientWithUrl, Method};
 use once_cell::sync::Lazy;
 use parking_lot::Mutex;
@@ -39,7 +39,6 @@ struct TelemetryState {
     installation_id: Option<Arc<str>>, // Per app installation (different for dev, nightly, preview, and stable)
     session_id: Option<String>,        // Per app launch
     release_channel: Option<&'static str>,
-    app_metadata: AppMetadata,
     architecture: &'static str,
     events_queue: Vec<EventWrapper>,
     flush_events_task: Option<Task<()>>,
@@ -48,6 +47,10 @@ struct TelemetryState {
     first_event_date_time: Option<DateTime<Utc>>,
     event_coalescer: EventCoalescer,
     max_queue_size: usize,
+
+    os_name: String,
+    app_version: String,
+    os_version: Option<String>,
 }
 
 #[cfg(debug_assertions)]
@@ -71,6 +74,87 @@ static ZED_CLIENT_CHECKSUM_SEED: Lazy<Option<Vec<u8>>> = Lazy::new(|| {
         })
 });
 
+pub fn os_name() -> String {
+    #[cfg(target_os = "macos")]
+    {
+        "macOS".to_string()
+    }
+    #[cfg(target_os = "linux")]
+    {
+        format!("Linux {}", gpui::guess_compositor())
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        "Windows".to_string()
+    }
+}
+
+/// Note: This might do blocking IO! Only call from background threads
+pub fn os_version() -> String {
+    #[cfg(target_os = "macos")]
+    {
+        use cocoa::base::nil;
+        use cocoa::foundation::NSProcessInfo;
+
+        unsafe {
+            let process_info = cocoa::foundation::NSProcessInfo::processInfo(nil);
+            let version = process_info.operatingSystemVersion();
+            gpui::SemanticVersion::new(
+                version.majorVersion as usize,
+                version.minorVersion as usize,
+                version.patchVersion as usize,
+            )
+            .to_string()
+        }
+    }
+    #[cfg(target_os = "linux")]
+    {
+        use std::path::Path;
+
+        let content = if let Ok(file) = std::fs::read_to_string(&Path::new("/etc/os-release")) {
+            file
+        } else if let Ok(file) = std::fs::read_to_string(&Path::new("/usr/lib/os-release")) {
+            file
+        } else {
+            log::error!("Failed to load /etc/os-release, /usr/lib/os-release");
+            "".to_string()
+        };
+        let mut name = "unknown".to_string();
+        let mut version = "unknown".to_string();
+
+        for line in content.lines() {
+            if line.starts_with("ID=") {
+                name = line.trim_start_matches("ID=").trim_matches('"').to_string();
+            }
+            if line.starts_with("VERSION_ID=") {
+                version = line
+                    .trim_start_matches("VERSION_ID=")
+                    .trim_matches('"')
+                    .to_string();
+            }
+        }
+
+        format!("{} {}", name, version)
+    }
+
+    #[cfg(target_os = "windows")]
+    {
+        let mut info = unsafe { std::mem::zeroed() };
+        let status = unsafe { windows::Wdk::System::SystemServices::RtlGetVersion(&mut info) };
+        if status.is_ok() {
+            gpui::SemanticVersion::new(
+                info.dwMajorVersion as _,
+                info.dwMinorVersion as _,
+                info.dwBuildNumber as _,
+            )
+            .to_string()
+        } else {
+            "unknown".to_string()
+        }
+    }
+}
+
 impl Telemetry {
     pub fn new(
         clock: Arc<dyn SystemClock>,
@@ -84,7 +168,6 @@ impl Telemetry {
 
         let state = Arc::new(Mutex::new(TelemetryState {
             settings: *TelemetrySettings::get_global(cx),
-            app_metadata: cx.app_metadata(),
             architecture: env::consts::ARCH,
             release_channel,
             installation_id: None,
@@ -97,6 +180,10 @@ impl Telemetry {
             first_event_date_time: None,
             event_coalescer: EventCoalescer::new(clock.clone()),
             max_queue_size: MAX_QUEUE_LEN,
+
+            os_version: None,
+            os_name: os_name(),
+            app_version: release_channel::AppVersion::global(cx).to_string(),
         }));
 
         #[cfg(not(debug_assertions))]
@@ -168,6 +255,9 @@ impl Telemetry {
         let mut state = self.state.lock();
         state.installation_id = installation_id.map(|id| id.into());
         state.session_id = Some(session_id);
+        state.app_version = release_channel::AppVersion::global(cx).to_string();
+        state.os_name = os_version();
+
         drop(state);
 
         let this = self.clone();
@@ -445,20 +535,14 @@ impl Telemetry {
 
                     {
                         let state = this.state.lock();
+
                         let request_body = EventRequestBody {
                             installation_id: state.installation_id.as_deref().map(Into::into),
                             session_id: state.session_id.clone(),
                             is_staff: state.is_staff,
-                            app_version: state
-                                .app_metadata
-                                .app_version
-                                .unwrap_or_default()
-                                .to_string(),
-                            os_name: state.app_metadata.os_name.to_string(),
-                            os_version: state
-                                .app_metadata
-                                .os_version
-                                .map(|version| version.to_string()),
+                            app_version: state.app_version.clone(),
+                            os_name: state.os_name.clone(),
+                            os_version: state.os_version.clone(),
                             architecture: state.architecture.to_string(),
 
                             release_channel: state.release_channel.map(Into::into),