Only show ssh logs when toggled (#43445)

Kirill Bulatov created 3 weeks ago

Same as in collab projects.

Release Notes:

- N/A

Change summary

crates/project/src/lsp_store/log_store.rs    | 44 ++++++++++++----------
crates/remote_server/src/headless_project.rs | 40 ++++++++++---------
2 files changed, 45 insertions(+), 39 deletions(-)

Detailed changes

crates/project/src/lsp_store/log_store.rs

@@ -344,22 +344,7 @@ impl LogStore {
                                 enabled,
                                 toggled_log_kind,
                             } => {
-                                if let Some(server_state) =
-                                    log_store.get_language_server_state(*server_id)
-                                {
-                                    if *enabled {
-                                        server_state.toggled_log_kind = Some(*toggled_log_kind);
-                                    } else {
-                                        server_state.toggled_log_kind = None;
-                                    }
-                                }
-                                if LogKind::Rpc == *toggled_log_kind {
-                                    if *enabled {
-                                        log_store.enable_rpc_trace_for_language_server(*server_id);
-                                    } else {
-                                        log_store.disable_rpc_trace_for_language_server(*server_id);
-                                    }
-                                }
+                                log_store.toggle_lsp_logs(*server_id, *enabled, *toggled_log_kind);
                             }
                             _ => {}
                         }
@@ -676,7 +661,6 @@ impl LogStore {
     }
 
     fn emit_event(&mut self, e: Event, cx: &mut Context<Self>) {
-        let on_headless_host = self.on_headless_host;
         match &e {
             Event::NewServerLogEntry { id, kind, text } => {
                 if let Some(state) = self.get_language_server_state(*id) {
@@ -690,9 +674,7 @@ impl LogStore {
                     }
                     .and_then(|lsp_store| lsp_store.read(cx).downstream_client());
                     if let Some((client, project_id)) = downstream_client {
-                        if on_headless_host
-                            || Some(LogKind::from_server_log_type(kind)) == state.toggled_log_kind
-                        {
+                        if Some(LogKind::from_server_log_type(kind)) == state.toggled_log_kind {
                             client
                                 .send(proto::LanguageServerLog {
                                     project_id,
@@ -709,4 +691,26 @@ impl LogStore {
 
         cx.emit(e);
     }
+
+    pub fn toggle_lsp_logs(
+        &mut self,
+        server_id: LanguageServerId,
+        enabled: bool,
+        toggled_log_kind: LogKind,
+    ) {
+        if let Some(server_state) = self.get_language_server_state(server_id) {
+            if enabled {
+                server_state.toggled_log_kind = Some(toggled_log_kind);
+            } else {
+                server_state.toggled_log_kind = None;
+            }
+        }
+        if LogKind::Rpc == toggled_log_kind {
+            if enabled {
+                self.enable_rpc_trace_for_language_server(server_id);
+            } else {
+                self.disable_rpc_trace_for_language_server(server_id);
+            }
+        }
+    }
 }

crates/remote_server/src/headless_project.rs

@@ -17,7 +17,7 @@ use project::{
     debugger::{breakpoint_store::BreakpointStore, dap_store::DapStore},
     git_store::GitStore,
     image_store::ImageId,
-    lsp_store::log_store::{self, GlobalLogStore, LanguageServerKind},
+    lsp_store::log_store::{self, GlobalLogStore, LanguageServerKind, LogKind},
     project_settings::SettingsObserver,
     search::SearchQuery,
     task_store::TaskStore,
@@ -623,26 +623,28 @@ impl HeadlessProject {
     async fn handle_toggle_lsp_logs(
         _: Entity<Self>,
         envelope: TypedEnvelope<proto::ToggleLspLogs>,
-        mut cx: AsyncApp,
+        cx: AsyncApp,
     ) -> Result<()> {
         let server_id = LanguageServerId::from_proto(envelope.payload.server_id);
-        let lsp_logs = cx
-            .update(|cx| {
-                cx.try_global::<GlobalLogStore>()
-                    .map(|lsp_logs| lsp_logs.0.clone())
-            })?
-            .context("lsp logs store is missing")?;
-
-        lsp_logs.update(&mut cx, |lsp_logs, _| {
-            // RPC logs are very noisy and we need to toggle it on the headless server too.
-            // The rest of the logs for the ssh project are very important to have toggled always,
-            // to e.g. send language server error logs to the client before anything is toggled.
-            if envelope.payload.enabled {
-                lsp_logs.enable_rpc_trace_for_language_server(server_id);
-            } else {
-                lsp_logs.disable_rpc_trace_for_language_server(server_id);
-            }
-        })?;
+        cx.update(|cx| {
+            let log_store = cx
+                .try_global::<GlobalLogStore>()
+                .map(|global_log_store| global_log_store.0.clone())
+                .context("lsp logs store is missing")?;
+            let toggled_log_kind =
+                match proto::toggle_lsp_logs::LogType::from_i32(envelope.payload.log_type)
+                    .context("invalid log type")?
+                {
+                    proto::toggle_lsp_logs::LogType::Log => LogKind::Logs,
+                    proto::toggle_lsp_logs::LogType::Trace => LogKind::Trace,
+                    proto::toggle_lsp_logs::LogType::Rpc => LogKind::Rpc,
+                };
+            log_store.update(cx, |log_store, _| {
+                log_store.toggle_lsp_logs(server_id, envelope.payload.enabled, toggled_log_kind);
+            });
+            anyhow::Ok(())
+        })??;
+
         Ok(())
     }