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/feedback/src/feedback.rs

@@ -1,5 +1,6 @@
 use gpui::{actions, AppContext, ClipboardItem, PromptLevel};
 use system_specs::SystemSpecs;
+use util::ResultExt;
 use workspace::Workspace;
 
 pub mod feedback_modal;
@@ -38,25 +39,38 @@ pub fn init(cx: &mut AppContext) {
         feedback_modal::FeedbackModal::register(workspace, cx);
         workspace
             .register_action(|_, _: &CopySystemSpecsIntoClipboard, cx| {
-                let specs = SystemSpecs::new(&cx).to_string();
+                let specs = SystemSpecs::new(&cx);
 
-                let prompt = cx.prompt(
-                    PromptLevel::Info,
-                    "Copied into clipboard",
-                    Some(&specs),
-                    &["OK"],
-                );
-                cx.spawn(|_, _cx| async move {
-                    prompt.await.ok();
+                cx.spawn(|_, mut cx| async move {
+                    let specs = specs.await.to_string();
+
+                    cx.update(|cx| cx.write_to_clipboard(ClipboardItem::new(specs.clone())))
+                        .log_err();
+
+                    cx.prompt(
+                        PromptLevel::Info,
+                        "Copied into clipboard",
+                        Some(&specs),
+                        &["OK"],
+                    )
+                    .await
+                    .ok();
                 })
                 .detach();
-                cx.write_to_clipboard(ClipboardItem::new(specs.clone()));
             })
             .register_action(|_, _: &RequestFeature, cx| {
                 cx.open_url(request_feature_url());
             })
             .register_action(move |_, _: &FileBugReport, cx| {
-                cx.open_url(&file_bug_report_url(&SystemSpecs::new(&cx)));
+                let specs = SystemSpecs::new(&cx);
+                cx.spawn(|_, mut cx| async move {
+                    let specs = specs.await;
+                    cx.update(|cx| {
+                        cx.open_url(&file_bug_report_url(&specs));
+                    })
+                    .log_err();
+                })
+                .detach();
             })
             .register_action(move |_, _: &OpenZedRepo, cx| {
                 cx.open_url(zed_repo_url());

crates/feedback/src/feedback_modal.rs

@@ -141,15 +141,15 @@ impl FeedbackModal {
                 return;
             }
 
+            let system_specs = SystemSpecs::new(cx);
             cx.spawn(|workspace, mut cx| async move {
                 let markdown = markdown.await.log_err();
                 let buffer = project.update(&mut cx, |project, cx| {
                     project.create_local_buffer("", markdown, cx)
                 })?;
+                let system_specs = system_specs.await;
 
                 workspace.update(&mut cx, |workspace, cx| {
-                    let system_specs = SystemSpecs::new(cx);
-
                     workspace.toggle_modal(cx, move |cx| {
                         FeedbackModal::new(system_specs, project, buffer, cx)
                     });

crates/feedback/src/system_specs.rs

@@ -1,4 +1,5 @@
-use gpui::AppContext;
+use client::telemetry;
+use gpui::{AppContext, Task};
 use human_bytes::human_bytes;
 use release_channel::{AppCommitSha, AppVersion, ReleaseChannel};
 use serde::Serialize;
@@ -9,27 +10,23 @@ use sysinfo::{MemoryRefreshKind, RefreshKind, System};
 pub struct SystemSpecs {
     app_version: String,
     release_channel: &'static str,
-    os_name: &'static str,
-    os_version: Option<String>,
+    os_name: String,
+    os_version: String,
     memory: u64,
     architecture: &'static str,
     commit_sha: Option<String>,
 }
 
 impl SystemSpecs {
-    pub fn new(cx: &AppContext) -> Self {
+    pub fn new(cx: &AppContext) -> Task<Self> {
         let app_version = AppVersion::global(cx).to_string();
         let release_channel = ReleaseChannel::global(cx);
-        let os_name = cx.app_metadata().os_name;
+        let os_name = telemetry::os_name();
         let system = System::new_with_specifics(
             RefreshKind::new().with_memory(MemoryRefreshKind::everything()),
         );
         let memory = system.total_memory();
         let architecture = env::consts::ARCH;
-        let os_version = cx
-            .app_metadata()
-            .os_version
-            .map(|os_version| os_version.to_string());
         let commit_sha = match release_channel {
             ReleaseChannel::Dev | ReleaseChannel::Nightly => {
                 AppCommitSha::try_global(cx).map(|sha| sha.0.clone())
@@ -37,24 +34,24 @@ impl SystemSpecs {
             _ => None,
         };
 
-        SystemSpecs {
-            app_version,
-            release_channel: release_channel.display_name(),
-            os_name,
-            os_version,
-            memory,
-            architecture,
-            commit_sha,
-        }
+        cx.background_executor().spawn(async move {
+            let os_version = telemetry::os_version();
+            SystemSpecs {
+                app_version,
+                release_channel: release_channel.display_name(),
+                os_name,
+                os_version,
+                memory,
+                architecture,
+                commit_sha,
+            }
+        })
     }
 }
 
 impl Display for SystemSpecs {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let os_information = match &self.os_version {
-            Some(os_version) => format!("OS: {} {}", self.os_name, os_version),
-            None => format!("OS: {}", self.os_name),
-        };
+        let os_information = format!("OS: {} {}", self.os_name, self.os_version);
         let app_version_information = format!(
             "Zed: v{} ({})",
             self.app_version,