Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

lsp: Reference-count log streams across views (#61222)

Shuhei Kadowaki4668a4bf0971
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rs
index 6c41ceb061d..647298c5895 100644
--- a/crates/collab/src/rpc.rs
+++ b/crates/collab/src/rpc.rs
@@ -534,7 +534,7 @@ impl Server {
.add_request_handler(disallow_guest_request::<proto::GitCreateArchiveCheckpoint>)
.add_request_handler(disallow_guest_request::<proto::GitRestoreArchiveCheckpoint>)
.add_request_handler(forward_mutating_project_request::<proto::CheckForPushedCommits>)
- .add_request_handler(forward_mutating_project_request::<proto::ToggleLspLogs>)
+ .add_message_handler(forward_toggle_lsp_logs)
.add_message_handler(broadcast_project_message_from_host::<proto::LanguageServerLog>)
.add_request_handler(forward_project_search_chunk)
.add_request_handler(forward_read_only_project_request::<proto::LoadCommitTemplate>);
@@ -2444,6 +2444,22 @@ where
Ok(())
}
+async fn forward_toggle_lsp_logs(
+ message: proto::ToggleLspLogs,
+ session: MessageContext,
+) -> Result<()> {
+ let project_id = ProjectId::from_proto(message.project_id);
+ let host_connection_id = session
+ .db()
+ .await
+ .host_for_mutating_project_request(project_id, session.connection_id)
+ .await?;
+ session
+ .peer
+ .forward_send(session.connection_id, host_connection_id, message)?;
+ Ok(())
+}
+
async fn disallow_guest_request<T>(
_request: T,
response: Response<T>,
diff --git a/crates/collab/tests/integration/integration_tests.rs b/crates/collab/tests/integration/integration_tests.rs
index 5650b26db98..77eeeeb53d0 100644
--- a/crates/collab/tests/integration/integration_tests.rs
+++ b/crates/collab/tests/integration/integration_tests.rs
@@ -10,7 +10,7 @@ use collab::rpc::{CLEANUP_TIMEOUT, RECONNECT_TIMEOUT};
use collections::{BTreeMap, HashMap, HashSet};
use fs::{FakeFs, Fs as _, RemoveOptions};
use futures::{
- StreamExt as _,
+ FutureExt as _, StreamExt as _,
channel::{mpsc, oneshot},
};
use git::{
@@ -32,7 +32,10 @@ use parking_lot::Mutex;
use pretty_assertions::assert_eq;
use project::{
DiagnosticSummary, HoverBlockKind, Project, ProjectPath,
- lsp_store::{FormatTrigger, LspFormatTarget, SymbolLocation},
+ lsp_store::{
+ FormatTrigger, LspFormatTarget, SymbolLocation,
+ log_store::{self, LanguageServerKind, LanguageServerLogKey, LogKind},
+ },
search::{SearchQuery, SearchResult},
};
use rand::prelude::*;
@@ -1478,6 +1481,613 @@ async fn test_unshare_project(
});
}
+#[gpui::test(iterations = 10)]
+async fn test_lsp_log_streams_reconnect_guest_first(
+ executor: BackgroundExecutor,
+ cx_host: &mut TestAppContext,
+ cx_guest: &mut TestAppContext,
+) {
+ assert_lsp_log_streams_reconnect(
+ executor,
+ cx_host,
+ cx_guest,
+ LspLogStreamsReconnectScenario::BothPeers { guest_first: true },
+ )
+ .await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_lsp_log_streams_reconnect_host_first(
+ executor: BackgroundExecutor,
+ cx_host: &mut TestAppContext,
+ cx_guest: &mut TestAppContext,
+) {
+ assert_lsp_log_streams_reconnect(
+ executor,
+ cx_host,
+ cx_guest,
+ LspLogStreamsReconnectScenario::BothPeers { guest_first: false },
+ )
+ .await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_lsp_log_streams_reconnect_guest_only_switch_to_trace(
+ executor: BackgroundExecutor,
+ cx_host: &mut TestAppContext,
+ cx_guest: &mut TestAppContext,
+) {
+ assert_lsp_log_streams_reconnect(
+ executor,
+ cx_host,
+ cx_guest,
+ LspLogStreamsReconnectScenario::SwitchToTraceWhileOffline,
+ )
+ .await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_lsp_log_streams_reconnect_guest_only_close(
+ executor: BackgroundExecutor,
+ cx_host: &mut TestAppContext,
+ cx_guest: &mut TestAppContext,
+) {
+ assert_lsp_log_streams_reconnect(
+ executor,
+ cx_host,
+ cx_guest,
+ LspLogStreamsReconnectScenario::CloseWhileOffline,
+ )
+ .await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_lsp_log_streams_reconnect_guest_only_close_one_view(
+ executor: BackgroundExecutor,
+ cx_host: &mut TestAppContext,
+ cx_guest: &mut TestAppContext,
+) {
+ assert_lsp_log_streams_reconnect(
+ executor,
+ cx_host,
+ cx_guest,
+ LspLogStreamsReconnectScenario::CloseOneViewWhileOffline,
+ )
+ .await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_lsp_log_streams_reconnect_without_views_does_not_exhaust_handlers(
+ executor: BackgroundExecutor,
+ cx_host: &mut TestAppContext,
+ cx_guest: &mut TestAppContext,
+) {
+ assert_lsp_log_streams_reconnect(
+ executor,
+ cx_host,
+ cx_guest,
+ LspLogStreamsReconnectScenario::ManyServersWithoutViews,
+ )
+ .await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_lsp_log_streams_reconnect_enable_during_replay(
+ executor: BackgroundExecutor,
+ cx_host: &mut TestAppContext,
+ cx_guest: &mut TestAppContext,
+) {
+ assert_lsp_log_streams_reconnect(
+ executor,
+ cx_host,
+ cx_guest,
+ LspLogStreamsReconnectScenario::EnableDuringReplay,
+ )
+ .await;
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_lsp_log_streams_reconnect_disable_during_replay(
+ executor: BackgroundExecutor,
+ cx_host: &mut TestAppContext,
+ cx_guest: &mut TestAppContext,
+) {
+ assert_lsp_log_streams_reconnect(
+ executor,
+ cx_host,
+ cx_guest,
+ LspLogStreamsReconnectScenario::DisableDuringReplay,
+ )
+ .await;
+}
+
+#[derive(Clone, Copy, Debug)]
+enum LspLogStreamsReconnectScenario {
+ BothPeers { guest_first: bool },
+ SwitchToTraceWhileOffline,
+ CloseWhileOffline,
+ CloseOneViewWhileOffline,
+ ManyServersWithoutViews,
+ EnableDuringReplay,
+ DisableDuringReplay,
+}
+
+async fn assert_lsp_log_streams_reconnect(
+ executor: BackgroundExecutor,
+ cx_host: &mut TestAppContext,
+ cx_guest: &mut TestAppContext,
+ scenario: LspLogStreamsReconnectScenario,
+) {
+ let mut server = TestServer::start(executor.clone()).await;
+ let host = server.create_client(cx_host, "host").await;
+ let guest = server.create_client(cx_guest, "guest").await;
+ let host_logs = cx_host.update(|cx| log_store::init(false, cx));
+ let guest_logs = cx_guest.update(|cx| log_store::init(false, cx));
+ server
+ .create_room(&mut [(&host, cx_host), (&guest, cx_guest)])
+ .await;
+
+ host.language_registry().add(Arc::new(Language::new(
+ LanguageConfig {
+ name: "Rust".into(),
+ matcher: LanguageMatcher {
+ path_suffixes: vec!["rs".to_string()],
+ ..Default::default()
+ }
+ .into(),
+ ..Default::default()
+ },
+ Some(tree_sitter_rust::LANGUAGE.into()),
+ )));
+ let mut language_servers = host
+ .language_registry()
+ .register_fake_lsp("Rust", Default::default());
+ host.fs()
+ .insert_tree(path!("/project"), json!({ "main.rs": "fn main() {}" }))
+ .await;
+ let (host_project, worktree_id) = host.build_local_project(path!("/project"), cx_host).await;
+ host_logs.update(cx_host, |store, cx| store.add_project(&host_project, cx));
+ let _buffer = host_project
+ .update(cx_host, |project, cx| {
+ project.open_local_buffer_with_lsp(path!("/project/main.rs"), cx)
+ })
+ .await
+ .expect("host should open the buffer and start its language server");
+ let mut language_server = language_servers
+ .next()
+ .await
+ .expect("host should start the fake Rust language server");
+ language_server
+ .receive_notification::<lsp::notification::DidOpenTextDocument>()
+ .await;
+
+ let active_call = cx_host.read(ActiveCall::global);
+ let project_id = active_call
+ .update(cx_host, |call, cx| {
+ call.share_project(host_project.clone(), cx)
+ })
+ .await
+ .expect("host should share the project");
+ // Sharing publishes language servers asynchronously; include them in the join snapshot.
+ executor.run_until_parked();
+ let guest_project = guest.join_remote_project(project_id, cx_guest).await;
+ guest_logs.update(cx_guest, |store, cx| store.add_project(&guest_project, cx));
+ executor.run_until_parked();
+
+ let server_id = language_server.server.server_id();
+ let host_key = LanguageServerLogKey::new(
+ LanguageServerKind::Local {
+ project: host_project.downgrade(),
+ },
+ server_id,
+ );
+ let guest_key = LanguageServerLogKey::new(
+ LanguageServerKind::Remote {
+ project: guest_project.downgrade(),
+ },
+ server_id,
+ );
+ if matches!(
+ scenario,
+ LspLogStreamsReconnectScenario::ManyServersWithoutViews
+ ) {
+ guest_logs.update(cx_guest, |store, cx| {
+ // Reconciliation sends three toggles per registered server, even without views.
+ // One real server plus 85 synthetic registrations exceeds collab's 256-handler budget.
+ for offset in 1..86 {
+ store
+ .add_language_server(
+ guest_key.kind.clone(),
+ LanguageServerId(server_id.0 + offset),
+ None,
+ None,
+ None,
+ cx,
+ )
+ .expect("guest should register the synthetic server");
+ }
+ assert_eq!(store.language_servers.len(), 86);
+ });
+ }
+ let initial_log_kinds: &[LogKind] = match scenario {
+ LspLogStreamsReconnectScenario::ManyServersWithoutViews
+ | LspLogStreamsReconnectScenario::EnableDuringReplay => &[],
+ LspLogStreamsReconnectScenario::SwitchToTraceWhileOffline => &[LogKind::Logs],
+ _ => &[LogKind::Logs, LogKind::Trace, LogKind::Rpc],
+ };
+ guest_logs.update(cx_guest, |store, cx| {
+ for &kind in initial_log_kinds {
+ store
+ .retain_view_log_stream(&guest_key, kind, cx)
+ .expect("guest should retain the existing server's stream");
+ if matches!(
+ scenario,
+ LspLogStreamsReconnectScenario::CloseOneViewWhileOffline
+ ) {
+ store
+ .retain_view_log_stream(&guest_key, kind, cx)
+ .expect("a second view should retain the same stream");
+ }
+ }
+ });
+ executor.run_until_parked();
+
+ let send_marker = |marker: &str| {
+ language_server.notify::<lsp::notification::LogMessage>(lsp::LogMessageParams {
+ typ: lsp::MessageType::INFO,
+ message: marker.to_string(),
+ });
+ language_server.notify::<lsp::notification::LogTrace>(lsp::LogTraceParams {
+ message: marker.to_string(),
+ verbose: None,
+ });
+ };
+ let guest_received = |marker: &str, cx: &TestAppContext| {
+ guest_logs.read_with(cx, |store, _| {
+ [
+ store
+ .server_logs(&guest_key)
+ .expect("guest server logs should remain registered")
+ .iter()
+ .any(|message| message.as_ref() == marker),
+ store
+ .server_trace(&guest_key)
+ .expect("guest server trace should remain registered")
+ .iter()
+ .any(|message| message.as_ref() == marker),
+ store
+ .language_servers
+ .get(&guest_key)
+ .expect("guest server should remain registered")
+ .rpc_state
+ .as_ref()
+ .is_some_and(|state| {
+ state
+ .rpc_messages
+ .iter()
+ .any(|message| message.as_ref().contains(marker))
+ }),
+ ]
+ })
+ };
+ send_marker("before reconnect");
+ executor.run_until_parked();
+ assert_eq!(
+ guest_received("before reconnect", cx_guest),
+ [LogKind::Logs, LogKind::Trace, LogKind::Rpc].map(|kind| initial_log_kinds.contains(&kind)),
+ "initial [Logs, Trace, Rpc] forwarding ({scenario:?})"
+ );
+
+ let forwarded_toggles = Rc::new(RefCell::new(Vec::new()));
+ let _host_subscription = cx_host.update(|cx| {
+ cx.subscribe(&host_project, {
+ let forwarded_toggles = forwarded_toggles.clone();
+ move |_, event, _| {
+ if let project::Event::ToggleLspLogs {
+ peer_id,
+ server_id,
+ enabled,
+ toggled_log_kind,
+ } = event
+ {
+ forwarded_toggles.borrow_mut().push((
+ *peer_id,
+ *server_id,
+ *toggled_log_kind,
+ *enabled,
+ ));
+ }
+ }
+ })
+ });
+ let rejoined = Rc::new(Cell::new(false));
+ let _subscription = cx_guest.update(|cx| {
+ cx.subscribe(&guest_project, {
+ let rejoined = rejoined.clone();
+ let guest_logs = guest_logs.clone();
+ let guest_key = guest_key.clone();
+ move |_, event, cx| {
+ if matches!(event, project::Event::Rejoined) {
+ rejoined.set(true);
+ if matches!(
+ scenario,
+ LspLogStreamsReconnectScenario::EnableDuringReplay
+ | LspLogStreamsReconnectScenario::DisableDuringReplay
+ ) {
+ // LogStore subscribed first, so replay is queued but cannot drain
+ // before this synchronous user toggle is queued behind it.
+ guest_logs.update(cx, |store, cx| {
+ for kind in [LogKind::Logs, LogKind::Trace, LogKind::Rpc] {
+ let result = if matches!(
+ scenario,
+ LspLogStreamsReconnectScenario::EnableDuringReplay
+ ) {
+ store.retain_view_log_stream(&guest_key, kind, cx)
+ } else {
+ store.release_view_log_stream(&guest_key, kind, cx)
+ };
+ result.expect("guest should toggle its view during replay");
+ }
+ });
+ }
+ }
+ }
+ })
+ });
+ let old_host_peer = host.peer_id().expect("host should initially be connected");
+ let old_guest_peer = guest
+ .peer_id()
+ .expect("guest should initially be connected");
+ server.forbid_connections();
+ if matches!(scenario, LspLogStreamsReconnectScenario::BothPeers { .. }) {
+ server.disconnect_client(old_host_peer);
+ }
+ server.disconnect_client(old_guest_peer);
+ executor.advance_clock(RECEIVE_TIMEOUT);
+ executor.run_until_parked();
+ assert!(!guest.status().borrow().is_connected());
+
+ if let LspLogStreamsReconnectScenario::BothPeers { guest_first } = scenario {
+ assert!(!host.status().borrow().is_connected());
+ server.allow_connections();
+ let (first, first_context, second, second_context) = if guest_first {
+ (&guest, &mut *cx_guest, &host, &mut *cx_host)
+ } else {
+ (&host, &mut *cx_host, &guest, &mut *cx_guest)
+ };
+ first
+ .connect(false, &first_context.to_async())
+ .await
+ .into_response()
+ .expect("first peer should reconnect without losing room membership");
+ executor.run_until_parked();
+ assert!(!second.status().borrow().is_connected());
+ assert_ne!(
+ first.peer_id().expect("first peer should be connected"),
+ if guest_first {
+ old_guest_peer
+ } else {
+ old_host_peer
+ }
+ );
+ if guest_first {
+ assert!(
+ rejoined.get(),
+ "guest should rejoin before the host returns"
+ );
+ // The disconnected host must miss the incremental peer update so its
+ // reshare snapshot removes the old guest's stream ownership.
+ host_project.read_with(second_context, |project, _| {
+ assert!(project.collaborators().contains_key(&old_guest_peer));
+ });
+ }
+ second
+ .connect(false, &second_context.to_async())
+ .await
+ .into_response()
+ .expect("second peer should reconnect without losing room membership");
+ } else {
+ assert!(host.status().borrow().is_connected());
+ host_project.read_with(cx_host, |project, _| {
+ assert!(project.collaborators().contains_key(&old_guest_peer));
+ });
+ if matches!(
+ scenario,
+ LspLogStreamsReconnectScenario::SwitchToTraceWhileOffline
+ | LspLogStreamsReconnectScenario::CloseWhileOffline
+ | LspLogStreamsReconnectScenario::CloseOneViewWhileOffline
+ ) {
+ // These disables cannot reach the online host; rejoin must reconcile
+ // ownership without replacing the project/store or toggling again.
+ guest_logs.update(cx_guest, |store, cx| {
+ for &kind in initial_log_kinds {
+ store
+ .release_view_log_stream(&guest_key, kind, cx)
+ .expect("guest should release its view while offline");
+ }
+ if matches!(
+ scenario,
+ LspLogStreamsReconnectScenario::SwitchToTraceWhileOffline
+ ) {
+ store
+ .retain_view_log_stream(&guest_key, LogKind::Trace, cx)
+ .expect("guest should switch to Trace while offline");
+ }
+ });
+ }
+ executor.run_until_parked();
+ assert!(!guest.status().borrow().is_connected());
+ server.allow_connections();
+ guest
+ .connect(false, &cx_guest.to_async())
+ .await
+ .into_response()
+ .expect("guest should reconnect without losing room membership");
+ }
+ executor.run_until_parked();
+ assert!(rejoined.get());
+ let new_host_peer = host.peer_id().expect("host should have reconnected");
+ let new_guest_peer = guest.peer_id().expect("guest should have reconnected");
+ if matches!(scenario, LspLogStreamsReconnectScenario::BothPeers { .. }) {
+ assert_ne!(old_host_peer, new_host_peer);
+ } else {
+ assert_eq!(old_host_peer, new_host_peer, "host must stay online");
+ }
+ assert_ne!(old_guest_peer, new_guest_peer);
+ host_project.read_with(cx_host, |project, _| {
+ assert!(project.collaborators().contains_key(&new_guest_peer));
+ assert!(!project.collaborators().contains_key(&old_guest_peer));
+ });
+ guest_project.read_with(cx_guest, |project, cx| {
+ assert!(!project.is_disconnected(cx));
+ assert!(project.collaborators().contains_key(&new_host_peer));
+ if old_host_peer != new_host_peer {
+ assert!(!project.collaborators().contains_key(&old_host_peer));
+ }
+ });
+
+ if matches!(
+ scenario,
+ LspLogStreamsReconnectScenario::ManyServersWithoutViews
+ ) {
+ let open_buffer = guest_project.update(cx_guest, |project, cx| {
+ project.open_buffer((worktree_id, rel_path("main.rs")), cx)
+ });
+ executor.run_until_parked();
+ open_buffer
+ .now_or_never()
+ .expect("a normal guest request must not stall behind unacknowledged log toggles")
+ .expect("guest should open a buffer after reconciliation");
+ let forwarded_toggles = forwarded_toggles.borrow();
+ assert_eq!(forwarded_toggles.len(), 86 * 3);
+ assert!(
+ forwarded_toggles
+ .iter()
+ .all(|(peer_id, _, _, enabled)| { *peer_id == new_guest_peer && !enabled })
+ );
+ }
+ if matches!(
+ scenario,
+ LspLogStreamsReconnectScenario::EnableDuringReplay
+ | LspLogStreamsReconnectScenario::DisableDuringReplay
+ ) {
+ let enabled = matches!(scenario, LspLogStreamsReconnectScenario::EnableDuringReplay);
+ let forwarded_toggles = forwarded_toggles.borrow();
+ assert_eq!(forwarded_toggles.len(), 6);
+ for kind in [LogKind::Logs, LogKind::Trace, LogKind::Rpc] {
+ assert_eq!(
+ forwarded_toggles
+ .iter()
+ .copied()
+ .filter(|(_, _, log_kind, _)| *log_kind == kind)
+ .collect::<Vec<_>>(),
+ vec![
+ (new_guest_peer, server_id, kind, !enabled),
+ (new_guest_peer, server_id, kind, enabled),
+ ],
+ "collab must preserve replay/user toggle order and the authenticated sender ({scenario:?})"
+ );
+ }
+ }
+ let remaining_log_kinds: &[LogKind] = match scenario {
+ LspLogStreamsReconnectScenario::SwitchToTraceWhileOffline => &[LogKind::Trace],
+ LspLogStreamsReconnectScenario::CloseWhileOffline
+ | LspLogStreamsReconnectScenario::ManyServersWithoutViews
+ | LspLogStreamsReconnectScenario::DisableDuringReplay => &[],
+ LspLogStreamsReconnectScenario::EnableDuringReplay => {
+ &[LogKind::Logs, LogKind::Trace, LogKind::Rpc]
+ }
+ _ => initial_log_kinds,
+ };
+ host_logs.read_with(cx_host, |store, _| {
+ assert_eq!(
+ store
+ .language_servers
+ .get(&host_key)
+ .expect("host server should remain registered")
+ .rpc_state
+ .is_some(),
+ remaining_log_kinds.contains(&LogKind::Rpc),
+ "host RPC capture must reflect the final guest stream ownership ({scenario:?})"
+ );
+ });
+ send_marker("after reconnect");
+ executor.run_until_parked();
+ let received_after_reconnect = guest_received("after reconnect", cx_guest);
+ for (kind, received) in [LogKind::Logs, LogKind::Trace, LogKind::Rpc]
+ .into_iter()
+ .zip(received_after_reconnect)
+ {
+ if remaining_log_kinds.contains(&kind) {
+ assert!(
+ received,
+ "{kind:?} should resume after reconnect ({scenario:?})"
+ );
+ }
+ }
+
+ // A replay must not acquire another view reference or retain the old peer.
+ guest_logs.update(cx_guest, |store, cx| {
+ for &kind in remaining_log_kinds {
+ store
+ .release_view_log_stream(&guest_key, kind, cx)
+ .expect("one release should disable the retained stream");
+ }
+ });
+ executor.run_until_parked();
+ send_marker("after disabling");
+ executor.run_until_parked();
+ host_logs.read_with(cx_host, |store, _| {
+ assert!(
+ store
+ .server_logs(&host_key)
+ .expect("host server logs should remain registered")
+ .iter()
+ .any(|message| message.as_ref() == "after disabling")
+ );
+ assert!(
+ store
+ .server_trace(&host_key)
+ .expect("host server trace should remain registered")
+ .iter()
+ .any(|message| message.as_ref() == "after disabling")
+ );
+ });
+ assert_eq!(
+ guest_received("after disabling", cx_guest),
+ [false; 3],
+ "[Logs, Trace, Rpc] forwarding must stop after the final release ({scenario:?})"
+ );
+ assert_eq!(
+ received_after_reconnect,
+ [LogKind::Logs, LogKind::Trace, LogKind::Rpc]
+ .map(|kind| remaining_log_kinds.contains(&kind)),
+ "rejoin must restore only the current [Logs, Trace, Rpc] streams ({scenario:?})"
+ );
+ host_logs.read_with(cx_host, |store, _| {
+ assert!(
+ store
+ .language_servers
+ .get(&host_key)
+ .expect("host server should remain registered")
+ .rpc_state
+ .is_none(),
+ "host should stop RPC capture after the guest releases its only reference"
+ );
+ });
+ guest_logs.read_with(cx_guest, |store, _| {
+ assert!(
+ store
+ .language_servers
+ .get(&guest_key)
+ .expect("guest server should remain registered")
+ .rpc_state
+ .is_none(),
+ "reconnect replay should not inflate the guest's view reference count"
+ );
+ });
+}
+
#[gpui::test(iterations = 10)]
async fn test_project_reconnect(
executor: BackgroundExecutor,
diff --git a/crates/language_tools/src/lsp_log_view.rs b/crates/language_tools/src/lsp_log_view.rs
index 338efb35e36..881a16e22e6 100644
--- a/crates/language_tools/src/lsp_log_view.rs
+++ b/crates/language_tools/src/lsp_log_view.rs
@@ -1,4 +1,4 @@
-use collections::VecDeque;
+use collections::{HashMap, HashSet, VecDeque};
use edit_prediction::EditPredictionStore;
use editor::{Editor, EditorEvent, MultiBufferOffset, actions::MoveToEnd, scroll::Autoscroll};
use gpui::{
@@ -18,11 +18,9 @@ use project::{
},
search::SearchQuery,
};
-use proto::toggle_lsp_logs::LogType;
use settings::SeedQuerySetting;
use std::{any::TypeId, borrow::Cow, sync::Arc};
use ui::{Checkbox, ContextMenu, PopoverMenu, ToggleState, prelude::*};
-use util::ResultExt as _;
use workspace::{
SplitDirection, ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace, WorkspaceId,
item::{Item, ItemHandle},
@@ -102,11 +100,17 @@ pub struct LspLogView {
log_store: Entity<LogStore>,
current_server_key: Option<LanguageServerLogKey>,
active_entry_kind: LogKind,
+ enabled_streams: HashMap<LanguageServerLogKey, EnabledLogStreams>,
project: Entity<Project>,
focus_handle: FocusHandle,
_log_store_subscriptions: Vec<Subscription>,
}
+struct EnabledLogStreams {
+ generation: usize,
+ log_kinds: HashSet<LogKind>,
+}
+
pub struct LspLogToolbarItemView {
log_view: Option<Entity<LspLogView>>,
_log_view_subscription: Option<Subscription>,
@@ -176,17 +180,35 @@ impl LspLogView {
.next();
let model_changes_subscription =
cx.observe_in(&log_store, window, move |this, store, window, cx| {
- let first_server_key_for_project = store
- .read(cx)
- .server_keys_for_project(&weak_project, &weak_lsp_store)
- .next();
- if let Some(current_key) = this.current_server_key.as_ref() {
- let current_server_is_for_project =
- store.read(cx).language_servers.contains_key(current_key)
- && current_key.is_for_project(&weak_project, &weak_lsp_store);
- if !current_server_is_for_project
- && let Some(server_key) = first_server_key_for_project
- {
+ this.prune_enabled_streams(cx);
+ let server_key = this
+ .current_server_key
+ .as_ref()
+ .filter(|key| {
+ store.read(cx).language_servers.contains_key(key)
+ && key.is_for_project(&weak_project, &weak_lsp_store)
+ })
+ .cloned()
+ .or_else(|| {
+ store
+ .read(cx)
+ .server_keys_for_project(&weak_project, &weak_lsp_store)
+ .next()
+ });
+ if let Some(server_key) = server_key {
+ let stream_is_enabled = this.active_entry_kind == LogKind::ServerInfo
+ || this
+ .enabled_streams
+ .get(&server_key)
+ .is_some_and(|streams| {
+ streams.log_kinds.contains(&this.active_entry_kind)
+ });
+ if this.current_server_key.as_ref() == Some(&server_key) {
+ if !stream_is_enabled {
+ // Rebuilding from the store would duplicate logs whose events are still queued.
+ this.set_stream_enabled(&server_key, this.active_entry_kind, true, cx);
+ }
+ } else {
match this.active_entry_kind {
LogKind::Rpc => this.show_rpc_trace_for_server(server_key, window, cx),
LogKind::Trace => this.show_trace_for_server(server_key, window, cx),
@@ -194,13 +216,6 @@ impl LspLogView {
LogKind::ServerInfo => this.show_server_info(server_key, window, cx),
}
}
- } else if let Some(server_key) = first_server_key_for_project {
- match this.active_entry_kind {
- LogKind::Rpc => this.show_rpc_trace_for_server(server_key, window, cx),
- LogKind::Trace => this.show_trace_for_server(server_key, window, cx),
- LogKind::Logs => this.show_logs_for_server(server_key, window, cx),
- LogKind::ServerInfo => this.show_server_info(server_key, window, cx),
- }
}
cx.notify();
@@ -261,18 +276,20 @@ impl LspLogView {
});
cx.on_release(|log_view, cx| {
- let project = log_view.project.downgrade();
- let lsp_store = log_view.project.read(cx).lsp_store().downgrade();
- log_view.log_store.update(cx, |log_store, cx| {
- for (key, state) in &log_store.language_servers {
- if key.is_for_project(&project, &lsp_store)
- && let Some(log_kind) = state.toggled_log_kind
- && let Some(log_type) = log_type(log_kind)
- {
- send_toggle_log_message(key, false, log_type, cx);
- }
- }
- });
+ let enabled_streams = log_view
+ .enabled_streams
+ .iter()
+ .flat_map(|(key, streams)| {
+ streams
+ .log_kinds
+ .iter()
+ .map(|log_kind| (key.clone(), *log_kind))
+ .collect::<Vec<_>>()
+ })
+ .collect::<Vec<_>>();
+ for (key, log_kind) in enabled_streams {
+ log_view.set_stream_enabled(&key, log_kind, false, cx);
+ }
})
.detach();
@@ -284,6 +301,7 @@ impl LspLogView {
log_store,
current_server_key: None,
active_entry_kind: LogKind::Logs,
+ enabled_streams: HashMap::default(),
_log_store_subscriptions: vec![
model_changes_subscription,
events_subscriptions,
@@ -408,7 +426,10 @@ impl LspLogView {
server_name: state.name.clone().unwrap_or(unknown_server.clone()),
server_kind: key.kind.clone(),
worktree_root_name,
- rpc_trace_enabled: state.rpc_state.is_some(),
+ rpc_trace_enabled: self.enabled_streams.get(key).is_some_and(|streams| {
+ streams.generation == state.generation
+ && streams.log_kinds.contains(&LogKind::Rpc)
+ }),
selected_entry: self.active_entry_kind,
trace_level: lsp::TraceValue::Off,
}
@@ -419,7 +440,10 @@ impl LspLogView {
server_name: state.name.clone().unwrap_or(unknown_server.clone()),
server_kind: key.kind.clone(),
worktree_root_name: "supplementary".to_string(),
- rpc_trace_enabled: state.rpc_state.is_some(),
+ rpc_trace_enabled: self.enabled_streams.get(key).is_some_and(|streams| {
+ streams.generation == state.generation
+ && streams.log_kinds.contains(&LogKind::Rpc)
+ }),
selected_entry: self.active_entry_kind,
trace_level: lsp::TraceValue::Off,
},
@@ -429,6 +453,133 @@ impl LspLogView {
Some(rows)
}
+ fn prune_enabled_streams(&mut self, cx: &App) {
+ let log_store = self.log_store.read(cx);
+ self.enabled_streams.retain(|key, streams| {
+ log_store
+ .language_servers
+ .get(key)
+ .is_some_and(|state| state.generation == streams.generation)
+ });
+ }
+
+ fn set_stream_enabled(
+ &mut self,
+ key: &LanguageServerLogKey,
+ log_kind: LogKind,
+ enabled: bool,
+ cx: &mut App,
+ ) {
+ // A view can be released before the observer sees a removed or replaced registration.
+ self.prune_enabled_streams(cx);
+ if enabled {
+ let already_enabled = self
+ .enabled_streams
+ .get(key)
+ .is_some_and(|streams| streams.log_kinds.contains(&log_kind));
+ if already_enabled {
+ return;
+ }
+ let Some(generation) = self.log_store.update(cx, |log_store, cx| {
+ log_store.retain_view_log_stream(key, log_kind, cx)?;
+ Some(log_store.get_language_server_state(key)?.generation)
+ }) else {
+ return;
+ };
+ self.enabled_streams
+ .entry(key.clone())
+ .or_insert_with(|| EnabledLogStreams {
+ generation,
+ log_kinds: HashSet::default(),
+ })
+ .log_kinds
+ .insert(log_kind);
+ } else {
+ let Some(streams) = self.enabled_streams.get_mut(key) else {
+ return;
+ };
+ if !streams.log_kinds.remove(&log_kind) {
+ return;
+ }
+ if streams.log_kinds.is_empty() {
+ self.enabled_streams.remove(key);
+ }
+ self.log_store.update(cx, |log_store, cx| {
+ log_store.release_view_log_stream(key, log_kind, cx);
+ });
+ }
+ }
+
+ fn set_visible_log_stream(
+ &mut self,
+ key: &LanguageServerLogKey,
+ log_kind: LogKind,
+ cx: &mut App,
+ ) {
+ self.set_stream_enabled(key, log_kind, true, cx);
+ let stream_is_enabled = self
+ .enabled_streams
+ .get(key)
+ .is_some_and(|streams| streams.log_kinds.contains(&log_kind));
+ if stream_is_enabled {
+ self.disable_visible_log_streams(Some((key, log_kind)), cx);
+ }
+ }
+
+ fn disable_visible_log_streams(
+ &mut self,
+ except: Option<(&LanguageServerLogKey, LogKind)>,
+ cx: &mut App,
+ ) {
+ let visible_log_streams = self
+ .enabled_streams
+ .iter()
+ .flat_map(|(key, streams)| {
+ streams
+ .log_kinds
+ .iter()
+ .filter(|log_kind| matches!(log_kind, LogKind::Logs | LogKind::Trace))
+ .map(|log_kind| (key.clone(), *log_kind))
+ .collect::<Vec<_>>()
+ })
+ .collect::<Vec<_>>();
+ for (key, log_kind) in visible_log_streams {
+ let should_preserve = except.is_some_and(|(except_key, except_kind)| {
+ except_key == &key && except_kind == log_kind
+ });
+ if !should_preserve {
+ self.set_stream_enabled(&key, log_kind, false, cx);
+ }
+ }
+ }
+
+ #[cfg(test)]
+ pub(crate) fn show_entry_for_test(
+ &mut self,
+ key: LanguageServerLogKey,
+ log_kind: LogKind,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ match log_kind {
+ LogKind::Rpc => self.show_rpc_trace_for_server(key, window, cx),
+ LogKind::Trace => self.show_trace_for_server(key, window, cx),
+ LogKind::Logs => self.show_logs_for_server(key, window, cx),
+ LogKind::ServerInfo => self.show_server_info(key, window, cx),
+ }
+ }
+
+ #[cfg(test)]
+ pub(crate) fn stream_enabled_for_test(
+ &self,
+ key: &LanguageServerLogKey,
+ log_kind: LogKind,
+ ) -> bool {
+ self.enabled_streams
+ .get(key)
+ .is_some_and(|streams| streams.log_kinds.contains(&log_kind))
+ }
+
fn show_logs_for_server(
&mut self,
key: LanguageServerLogKey,
@@ -453,15 +604,10 @@ impl LspLogView {
let (editor, editor_subscriptions) = Self::editor_for_logs(log_contents, window, cx);
self.editor = editor;
self.editor_subscriptions = editor_subscriptions;
+ self.set_visible_log_stream(&key, LogKind::Logs, cx);
cx.notify();
}
self.editor.read(cx).focus_handle(cx).focus(window, cx);
- self.log_store.update(cx, |log_store, cx| {
- let state = log_store.get_language_server_state(&key)?;
- state.toggled_log_kind = Some(LogKind::Logs);
- send_toggle_log_message(&key, true, LogType::Log, cx);
- Some(())
- });
}
fn update_log_level(
@@ -513,12 +659,7 @@ impl LspLogView {
let (editor, editor_subscriptions) = Self::editor_for_logs(log_contents, window, cx);
self.editor = editor;
self.editor_subscriptions = editor_subscriptions;
- self.log_store.update(cx, |log_store, cx| {
- let state = log_store.get_language_server_state(&key)?;
- state.toggled_log_kind = Some(LogKind::Trace);
- send_toggle_log_message(&key, true, LogType::Trace, cx);
- Some(())
- });
+ self.set_visible_log_stream(&key, LogKind::Trace, cx);
cx.notify();
}
self.editor.read(cx).focus_handle(cx).focus(window, cx);
@@ -533,10 +674,13 @@ impl LspLogView {
self.toggle_rpc_trace_for_server(key.clone(), true, window, cx);
let rpc_log = self.log_store.update(cx, |log_store, _| {
log_store
- .enable_rpc_trace_for_language_server(&key)
+ .get_language_server_state(&key)?
+ .rpc_state
+ .as_ref()
.map(|state| log_contents(&state.rpc_messages, ()))
});
if let Some(rpc_log) = rpc_log {
+ self.disable_visible_log_streams(None, cx);
self.current_server_key = Some(key);
self.active_entry_kind = LogKind::Rpc;
let (editor, editor_subscriptions) = Self::editor_for_logs(rpc_log, window, cx);
@@ -575,17 +719,7 @@ impl LspLogView {
window: &mut Window,
cx: &mut Context<Self>,
) {
- self.log_store.update(cx, |log_store, cx| {
- if enabled {
- log_store.enable_rpc_trace_for_language_server(&key);
- } else {
- log_store.disable_rpc_trace_for_language_server(&key);
- }
-
- if log_store.language_servers.contains_key(&key) {
- send_toggle_log_message(&key, enabled, LogType::Rpc, cx);
- }
- });
+ self.set_stream_enabled(&key, LogKind::Rpc, enabled, cx);
if !enabled && self.current_server_key.as_ref() == Some(&key) {
self.show_logs_for_server(key, window, cx);
cx.notify();
@@ -665,55 +799,14 @@ impl LspLogView {
let Some(server_info) = server_info else {
return;
};
- self.current_server_key = Some(key.clone());
+ self.current_server_key = Some(key);
self.active_entry_kind = LogKind::ServerInfo;
let (editor, editor_subscriptions) = Self::editor_for_server_info(server_info, window, cx);
self.editor = editor;
self.editor_subscriptions = editor_subscriptions;
cx.notify();
self.editor.read(cx).focus_handle(cx).focus(window, cx);
- self.log_store.update(cx, |log_store, cx| {
- let state = log_store.get_language_server_state(&key)?;
- if let Some(log_kind) = state.toggled_log_kind.take()
- && let Some(log_type) = log_type(log_kind)
- {
- send_toggle_log_message(&key, false, log_type, cx);
- }
- Some(())
- });
- }
-}
-
-fn log_type(log_kind: LogKind) -> Option<LogType> {
- match log_kind {
- LogKind::Rpc => Some(LogType::Rpc),
- LogKind::Trace => Some(LogType::Trace),
- LogKind::Logs => Some(LogType::Log),
- LogKind::ServerInfo => None,
- }
-}
-
-fn send_toggle_log_message(
- key: &LanguageServerLogKey,
- enabled: bool,
- log_type: LogType,
- cx: &mut App,
-) {
- if let LanguageServerKind::Remote { project } = &key.kind {
- project
- .update(cx, |project, cx| {
- if let Some((client, project_id)) = project.lsp_store().read(cx).upstream_client() {
- client
- .send(proto::ToggleLspLogs {
- project_id,
- log_type: log_type as i32,
- server_id: key.server_id.to_proto(),
- enabled,
- })
- .log_err();
- }
- })
- .ok();
+ self.disable_visible_log_streams(None, cx);
}
}
diff --git a/crates/language_tools/src/lsp_log_view_tests.rs b/crates/language_tools/src/lsp_log_view_tests.rs
index 33512fbe199..e0bf15f2c3a 100644
--- a/crates/language_tools/src/lsp_log_view_tests.rs
+++ b/crates/language_tools/src/lsp_log_view_tests.rs
@@ -4,15 +4,16 @@ use crate::lsp_log_view::LogMenuItem;
use super::*;
use futures::StreamExt;
-use gpui::{AppContext as _, TestAppContext, VisualTestContext};
+use gpui::{AppContext as _, TestAppContext, VisualContext as _, VisualTestContext};
use language::{
FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, LanguageServerId, tree_sitter_rust,
};
use lsp::LanguageServerName;
use project::{
- FakeFs, Project,
+ Event as ProjectEvent, FakeFs, Project,
lsp_store::log_store::{LanguageServerKind, LanguageServerLogKey, LogKind, LogStore},
};
+use proto::PeerId;
use serde_json::json;
use settings::SettingsStore;
use util::path;
@@ -190,6 +191,230 @@ async fn test_lsp_log_view_labels_registered_supplementary_servers(cx: &mut Test
});
}
+#[gpui::test]
+async fn test_lsp_log_view_rpc_checkbox_tracks_view_ownership(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(path!("/rpc-ownership"), json!({ "test.rs": "" }))
+ .await;
+ let project = Project::test(fs, [path!("/rpc-ownership").as_ref()], cx).await;
+ let log_store = cx.new(|cx| LogStore::new(false, cx));
+ let server_keys = [
+ LanguageServerKind::Local {
+ project: project.downgrade(),
+ },
+ LanguageServerKind::Supplementary {
+ project: project.downgrade(),
+ },
+ ]
+ .map(|kind| LanguageServerLogKey::new(kind, LanguageServerId(100)));
+ log_store.update(cx, |store, cx| {
+ store.add_project(&project, cx);
+ for server_key in &server_keys {
+ store.add_language_server(
+ server_key.kind.clone(),
+ server_key.server_id,
+ Some(LanguageServerName::new_static("test-server")),
+ None,
+ None,
+ cx,
+ );
+ assert_eq!(
+ store.set_downstream_log_stream(
+ server_key,
+ PeerId { owner_id: 1, id: 1 },
+ LogKind::Rpc,
+ true,
+ cx,
+ ),
+ Some(())
+ );
+ }
+ });
+
+ let window =
+ cx.add_window(|window, cx| LspLogView::new(project.clone(), log_store, window, cx));
+ let log_view = window.root(cx).expect("log view should exist");
+ let mut cx = VisualTestContext::from_window(*window, cx);
+ log_view.update_in(&mut cx, |view, window, cx| {
+ for enabled in [false, true] {
+ if enabled {
+ for server_key in &server_keys {
+ view.show_entry_for_test(server_key.clone(), LogKind::Rpc, window, cx);
+ }
+ }
+ let menu_items = view.menu_items(cx).expect("server menu should exist");
+ assert_eq!(menu_items.len(), server_keys.len());
+ assert!(
+ menu_items
+ .iter()
+ .all(|item| item.rpc_trace_enabled == enabled)
+ );
+ }
+ });
+}
+
+async fn rpc_registration_fixture(
+ cx: &mut TestAppContext,
+) -> (
+ Entity<Project>,
+ Entity<LogStore>,
+ LanguageServerLogKey,
+ VisualTestContext,
+) {
+ let project = Project::test(FakeFs::new(cx.background_executor.clone()), [], cx).await;
+ let log_store = cx.new(|cx| LogStore::new(false, cx));
+ let key = LanguageServerLogKey::new(
+ LanguageServerKind::Local {
+ project: project.downgrade(),
+ },
+ LanguageServerId(100),
+ );
+ log_store.update(cx, |store, cx| {
+ store.add_project(&project, cx);
+ store.add_language_server(key.kind.clone(), key.server_id, None, None, None, cx);
+ });
+ let window = cx.add_window(|_, _| gpui::Empty);
+ let cx = VisualTestContext::from_window(*window, cx);
+ (project, log_store, key, cx)
+}
+
+fn assert_rpc_registration(
+ log_store: &Entity<LogStore>,
+ key: &LanguageServerLogKey,
+ enabled: bool,
+ cx: &VisualTestContext,
+) {
+ log_store.read_with(cx, |store, _| {
+ assert_eq!(
+ store
+ .language_servers
+ .get(key)
+ .map(|state| state.rpc_state.is_some()),
+ Some(enabled),
+ );
+ });
+}
+
+#[gpui::test]
+async fn test_lsp_log_view_replacement_refreshes_rpc_ownership(cx: &mut TestAppContext) {
+ init_test(cx);
+ for (batched, active_entry) in [
+ (false, LogKind::Logs),
+ (true, LogKind::Logs),
+ (false, LogKind::Rpc),
+ (true, LogKind::Rpc),
+ ] {
+ let (project, log_store, key, mut cx) = rpc_registration_fixture(cx).await;
+ let log_view = cx.new_window_entity(|window, cx| {
+ LspLogView::new(project.clone(), log_store.clone(), window, cx)
+ });
+ cx.update(|window, cx| {
+ log_view.update(cx, |view, cx| {
+ view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
+ view.show_entry_for_test(key.clone(), active_entry, window, cx);
+ assert!(view.stream_enabled_for_test(&key, LogKind::Rpc));
+ });
+ });
+ if !batched {
+ log_store.update(&mut cx, |store, cx| store.remove_language_server(&key, cx));
+ log_view.update(&mut cx, |view, cx| {
+ assert!(!view.stream_enabled_for_test(&key, LogKind::Rpc));
+ assert!(view.menu_items(cx).expect("server menu").is_empty());
+ });
+ }
+ cx.update(|_, cx| {
+ log_store.update(cx, |store, cx| {
+ if batched {
+ store.remove_language_server(&key, cx);
+ }
+ store.add_language_server(key.kind.clone(), key.server_id, None, None, None, cx);
+ store.add_language_server_log(&key, lsp::MessageType::LOG, "replacement log", cx);
+ });
+ });
+ let rpc_is_visible = active_entry == LogKind::Rpc;
+ assert_rpc_registration(&log_store, &key, rpc_is_visible, &cx);
+ cx.update(|window, cx| {
+ log_view.update(cx, |view, cx| {
+ if active_entry == LogKind::Logs {
+ assert_eq!(view.editor.read(cx).text(cx), "replacement log\n");
+ }
+ assert_eq!(
+ view.stream_enabled_for_test(&key, LogKind::Rpc),
+ rpc_is_visible
+ );
+ let menu = view.menu_items(cx).expect("server menu");
+ assert_eq!(menu.len(), 1);
+ assert_eq!(
+ menu.first().expect("replacement server").rpc_trace_enabled,
+ rpc_is_visible
+ );
+ for _ in 0..2 {
+ view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
+ assert!(view.stream_enabled_for_test(&key, LogKind::Rpc));
+ }
+ });
+ });
+ assert_rpc_registration(&log_store, &key, true, &cx);
+ cx.update(|_, _| drop(log_view));
+ assert_rpc_registration(&log_store, &key, false, &cx);
+ }
+}
+
+#[gpui::test]
+async fn test_lsp_log_view_release_before_observer_preserves_replacement_rpc(
+ cx: &mut TestAppContext,
+) {
+ init_test(cx);
+ for reenable_old_owner in [false, true] {
+ let (project, log_store, key, mut cx) = rpc_registration_fixture(cx).await;
+ let mut new_view = || {
+ cx.new_window_entity(|window, cx| {
+ LspLogView::new(project.clone(), log_store.clone(), window, cx)
+ })
+ };
+ let old_owner = new_view();
+ let new_owner = new_view();
+ cx.update(|window, cx| {
+ old_owner.update(cx, |view, cx| {
+ view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
+ });
+ });
+ cx.update(|window, cx| {
+ log_store.update(cx, |store, cx| {
+ store.remove_language_server(&key, cx);
+ store.add_language_server(key.kind.clone(), key.server_id, None, None, None, cx);
+ });
+ old_owner.update(cx, |view, cx| {
+ let menu = view.menu_items(cx).expect("server menu");
+ assert!(!menu.first().expect("replacement server").rpc_trace_enabled);
+ if reenable_old_owner {
+ view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
+ }
+ });
+ if reenable_old_owner {
+ assert!(
+ log_store
+ .read(cx)
+ .language_servers
+ .get(&key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ );
+ }
+ new_owner.update(cx, |view, cx| {
+ assert!(!view.stream_enabled_for_test(&key, LogKind::Rpc));
+ view.show_entry_for_test(key.clone(), LogKind::Rpc, window, cx);
+ });
+ // Release runs before the coalesced notification can prune the old ownership.
+ drop(old_owner);
+ });
+ assert_rpc_registration(&log_store, &key, true, &cx);
+ cx.update(|_, _| drop(new_owner));
+ assert_rpc_registration(&log_store, &key, false, &cx);
+ }
+}
+
#[gpui::test]
async fn test_log_store_does_not_retain_language_servers(cx: &mut TestAppContext) {
init_test(cx);
@@ -322,6 +547,248 @@ async fn test_log_store_removes_unavailable_copilot_server(cx: &mut TestAppConte
}));
}
+#[gpui::test]
+async fn test_local_views_and_downstream_peers_own_rpc_streams_independently(
+ cx: &mut TestAppContext,
+) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(path!("/stream-ownership"), json!({ "test.rs": "" }))
+ .await;
+ let project = Project::test(fs, [path!("/stream-ownership").as_ref()], cx).await;
+ let server_id = LanguageServerId(100);
+ let server_key = LanguageServerLogKey::new(
+ LanguageServerKind::Local {
+ project: project.downgrade(),
+ },
+ server_id,
+ );
+ let first_peer_id = PeerId { owner_id: 1, id: 1 };
+ let second_peer_id = PeerId { owner_id: 2, id: 2 };
+ let log_store = cx.new(|cx| LogStore::new(false, cx));
+
+ log_store.update(cx, |store, cx| {
+ store.add_project(&project, cx);
+ store.add_language_server(
+ server_key.kind.clone(),
+ server_id,
+ Some(LanguageServerName::new_static("test-server")),
+ None,
+ None,
+ cx,
+ );
+ });
+
+ for peer_id in [first_peer_id, second_peer_id] {
+ project.update(cx, |_, cx| {
+ cx.emit(ProjectEvent::ToggleLspLogs {
+ peer_id,
+ server_id,
+ enabled: true,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ }
+ project.update(cx, |_, cx| {
+ cx.emit(ProjectEvent::ToggleLspLogs {
+ peer_id: first_peer_id,
+ server_id,
+ enabled: false,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ assert!(log_store.read_with(cx, |store, _| {
+ store
+ .language_servers
+ .get(&server_key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ }));
+ project.update(cx, |_, cx| {
+ cx.emit(ProjectEvent::CollaboratorLeft(second_peer_id));
+ });
+ assert!(log_store.read_with(cx, |store, _| {
+ store
+ .language_servers
+ .get(&server_key)
+ .is_some_and(|state| state.rpc_state.is_none())
+ }));
+
+ project.update(cx, |_, cx| {
+ cx.emit(ProjectEvent::ToggleLspLogs {
+ peer_id: first_peer_id,
+ server_id,
+ enabled: true,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ log_store.update(cx, |store, cx| {
+ assert_eq!(
+ store.retain_view_log_stream(&server_key, LogKind::Rpc, cx),
+ Some(())
+ );
+ assert_eq!(
+ store.release_view_log_stream(&server_key, LogKind::Rpc, cx),
+ Some(())
+ );
+ });
+ assert!(
+ log_store.read_with(cx, |store, _| {
+ store
+ .language_servers
+ .get(&server_key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ }),
+ "releasing the final local view must preserve a downstream peer's RPC stream"
+ );
+ project.update(cx, |_, cx| {
+ cx.emit(ProjectEvent::ToggleLspLogs {
+ peer_id: first_peer_id,
+ server_id,
+ enabled: false,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ assert!(log_store.read_with(cx, |store, _| {
+ store
+ .language_servers
+ .get(&server_key)
+ .is_some_and(|state| state.rpc_state.is_none())
+ }));
+
+ log_store.update(cx, |store, cx| {
+ assert_eq!(
+ store.retain_view_log_stream(&server_key, LogKind::Rpc, cx),
+ Some(())
+ );
+ });
+ project.update(cx, |_, cx| {
+ cx.emit(ProjectEvent::ToggleLspLogs {
+ peer_id: first_peer_id,
+ server_id,
+ enabled: true,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ cx.emit(ProjectEvent::ToggleLspLogs {
+ peer_id: first_peer_id,
+ server_id,
+ enabled: false,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ assert!(
+ log_store.read_with(cx, |store, _| {
+ store
+ .language_servers
+ .get(&server_key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ }),
+ "disabling a downstream peer's RPC stream must preserve a local view's stream"
+ );
+ log_store.update(cx, |store, cx| {
+ assert_eq!(
+ store.release_view_log_stream(&server_key, LogKind::Rpc, cx),
+ Some(())
+ );
+ });
+ assert!(log_store.read_with(cx, |store, _| {
+ store
+ .language_servers
+ .get(&server_key)
+ .is_some_and(|state| state.rpc_state.is_none())
+ }));
+
+ project.update(cx, |_, cx| {
+ cx.emit(ProjectEvent::ToggleLspLogs {
+ peer_id: first_peer_id,
+ server_id,
+ enabled: true,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ cx.emit(ProjectEvent::CollaboratorUpdated {
+ old_peer_id: first_peer_id,
+ new_peer_id: second_peer_id,
+ });
+ cx.emit(ProjectEvent::ToggleLspLogs {
+ peer_id: second_peer_id,
+ server_id,
+ enabled: false,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ assert!(log_store.read_with(cx, |store, _| {
+ store
+ .language_servers
+ .get(&server_key)
+ .is_some_and(|state| state.rpc_state.is_none())
+ }));
+}
+
+#[gpui::test]
+async fn test_unsharing_releases_only_project_downstream_rpc_streams(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ let project = Project::test(fs.clone(), [], cx).await;
+ let other_project = Project::test(fs, [], cx).await;
+ let server_keys = [
+ (project.downgrade(), LanguageServerId(100)),
+ (project.downgrade(), LanguageServerId(101)),
+ (other_project.downgrade(), LanguageServerId(100)),
+ ]
+ .map(|(project, server_id)| {
+ LanguageServerLogKey::new(LanguageServerKind::Local { project }, server_id)
+ });
+ let [_, local_view_key, _] = &server_keys;
+ let log_store = cx.new(|cx| LogStore::new(false, cx));
+ log_store.update(cx, |store, cx| {
+ store.add_project(&project, cx);
+ store.add_project(&other_project, cx);
+ for server_key in &server_keys {
+ store.add_language_server(
+ server_key.kind.clone(),
+ server_key.server_id,
+ None,
+ None,
+ None,
+ cx,
+ );
+ for peer_id in [PeerId { owner_id: 1, id: 1 }, PeerId { owner_id: 2, id: 2 }] {
+ store.set_downstream_log_stream(server_key, peer_id, LogKind::Rpc, true, cx);
+ }
+ }
+ store.retain_view_log_stream(local_view_key, LogKind::Rpc, cx);
+ });
+
+ project
+ .update(cx, |project, cx| project.shared(1, cx))
+ .expect("project should be shareable");
+ project
+ .update(cx, |project, cx| project.unshare(cx))
+ .expect("shared project should unshare");
+
+ log_store.update(cx, |store, cx| {
+ for (server_key, rpc_enabled) in server_keys.iter().zip([false, true, true]) {
+ assert_eq!(
+ store
+ .language_servers
+ .get(server_key)
+ .map(|state| state.rpc_state.is_some()),
+ Some(rpc_enabled),
+ "unsharing must preserve local views and other projects"
+ );
+ }
+ store.release_view_log_stream(local_view_key, LogKind::Rpc, cx);
+ assert!(
+ store
+ .language_servers
+ .get(local_view_key)
+ .is_some_and(|state| state.rpc_state.is_none()),
+ "unsharing must release every downstream peer even while a local view owns the stream"
+ );
+ });
+}
+
#[gpui::test]
async fn test_lsp_log_view(cx: &mut TestAppContext) {
zlog::init_test();
@@ -375,6 +842,18 @@ async fn test_lsp_log_view(cx: &mut TestAppContext) {
language_server
.receive_notification::<lsp::notification::DidOpenTextDocument>()
.await;
+ let server_key = LanguageServerLogKey::new(
+ LanguageServerKind::Local {
+ project: project.downgrade(),
+ },
+ language_server.server.server_id(),
+ );
+ let unavailable_server_key = LanguageServerLogKey::new(
+ LanguageServerKind::Local {
+ project: project.downgrade(),
+ },
+ LanguageServerId(999),
+ );
let window =
cx.add_window(|window, cx| LspLogView::new(project.clone(), log_store.clone(), window, cx));
@@ -411,6 +890,45 @@ async fn test_lsp_log_view(cx: &mut TestAppContext) {
);
assert_eq!(view.editor.read(cx).text(cx), "hello from the server\n");
});
+
+ log_view.update_in(&mut cx, |view, window, cx| {
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Logs));
+
+ view.show_entry_for_test(server_key.clone(), LogKind::Trace, window, cx);
+ assert!(!view.stream_enabled_for_test(&server_key, LogKind::Logs));
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Trace));
+
+ view.show_entry_for_test(server_key.clone(), LogKind::Rpc, window, cx);
+ assert!(!view.stream_enabled_for_test(&server_key, LogKind::Logs));
+ assert!(!view.stream_enabled_for_test(&server_key, LogKind::Trace));
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));
+
+ view.show_entry_for_test(server_key.clone(), LogKind::Logs, window, cx);
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Logs));
+ assert!(!view.stream_enabled_for_test(&server_key, LogKind::Trace));
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));
+
+ view.show_entry_for_test(server_key.clone(), LogKind::Trace, window, cx);
+ assert!(!view.stream_enabled_for_test(&server_key, LogKind::Logs));
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Trace));
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));
+
+ view.show_entry_for_test(server_key.clone(), LogKind::ServerInfo, window, cx);
+ assert!(!view.stream_enabled_for_test(&server_key, LogKind::Logs));
+ assert!(!view.stream_enabled_for_test(&server_key, LogKind::Trace));
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));
+
+ view.show_entry_for_test(server_key.clone(), LogKind::Logs, window, cx);
+ view.show_entry_for_test(unavailable_server_key.clone(), LogKind::Logs, window, cx);
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Logs));
+ assert!(!view.stream_enabled_for_test(&unavailable_server_key, LogKind::Logs));
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));
+
+ view.show_entry_for_test(unavailable_server_key.clone(), LogKind::Rpc, window, cx);
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Logs));
+ assert!(!view.stream_enabled_for_test(&unavailable_server_key, LogKind::Rpc));
+ assert!(view.stream_enabled_for_test(&server_key, LogKind::Rpc));
+ });
}
fn init_test(cx: &mut gpui::TestAppContext) {
diff --git a/crates/project/src/lsp_store/log_store.rs b/crates/project/src/lsp_store/log_store.rs
index c6da6b5cd91..713dcf7b7a4 100644
--- a/crates/project/src/lsp_store/log_store.rs
+++ b/crates/project/src/lsp_store/log_store.rs
@@ -4,7 +4,7 @@ use std::{
time::{Duration, Instant},
};
-use collections::HashMap;
+use collections::{HashMap, HashSet};
use futures::{StreamExt, channel::mpsc};
use gpui::{
App, AppContext as _, Context, Entity, EventEmitter, Global, Subscription, TaskExt, WeakEntity,
@@ -16,6 +16,7 @@ use lsp::{
use rpc::proto;
use serde::Deserialize;
use settings::WorktreeId;
+use util::ResultExt as _;
use crate::{LanguageServerLogType, LspStore, Project, ProjectItem as _};
@@ -47,6 +48,7 @@ pub struct LogStore {
on_headless_host: bool,
projects: HashMap<WeakEntity<Project>, ProjectState>,
pub language_servers: HashMap<LanguageServerLogKey, LanguageServerState>,
+ next_server_generation: usize,
io_tx: mpsc::UnboundedSender<(LanguageServerLogKey, IoKind, String, Instant)>,
}
@@ -131,6 +133,8 @@ impl Message for RpcMessage {
}
pub struct LanguageServerState {
+ /// Distinguishes a re-registered key from the registration owned by an older view.
+ pub generation: usize,
pub name: Option<LanguageServerName>,
pub worktree_id: Option<WorktreeId>,
server: Option<Weak<LanguageServer>>,
@@ -140,18 +144,47 @@ pub struct LanguageServerState {
pub trace_level: TraceValue,
pub log_level: MessageType,
io_logs_subscription: Option<lsp::Subscription>,
- pub toggled_log_kind: Option<LogKind>,
+ view_log_stream_refcounts: HashMap<LogKind, usize>,
+ downstream_log_streams: HashMap<proto::PeerId, HashSet<LogKind>>,
}
impl LanguageServerState {
pub fn server(&self) -> Option<Arc<LanguageServer>> {
self.server.as_ref()?.upgrade()
}
+
+ fn has_view_log_stream(&self, log_kind: LogKind) -> bool {
+ self.view_log_stream_refcounts.contains_key(&log_kind)
+ }
+
+ fn has_downstream_log_stream(&self, log_kind: LogKind) -> bool {
+ self.downstream_log_streams
+ .values()
+ .any(|log_kinds| log_kinds.contains(&log_kind))
+ }
+
+ fn has_log_stream(&self, log_kind: LogKind) -> bool {
+ self.has_view_log_stream(log_kind) || self.has_downstream_log_stream(log_kind)
+ }
+
+ fn synchronize_rpc_state(&mut self) {
+ if self.has_log_stream(LogKind::Rpc) {
+ self.rpc_state
+ .get_or_insert_with(|| LanguageServerRpcState {
+ rpc_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
+ header_state: RpcLogHeaderState::default(),
+ request_tracker: RpcRequestTracker::default(),
+ });
+ } else {
+ self.rpc_state.take();
+ }
+ }
}
impl std::fmt::Debug for LanguageServerState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("LanguageServerState")
+ .field("generation", &self.generation)
.field("name", &self.name)
.field("worktree_id", &self.worktree_id)
.field("log_messages", &self.log_messages)
@@ -159,7 +192,8 @@ impl std::fmt::Debug for LanguageServerState {
.field("rpc_state", &self.rpc_state)
.field("trace_level", &self.trace_level)
.field("log_level", &self.log_level)
- .field("toggled_log_kind", &self.toggled_log_kind)
+ .field("view_log_stream_refcounts", &self.view_log_stream_refcounts)
+ .field("downstream_log_streams", &self.downstream_log_streams)
.finish_non_exhaustive()
}
}
@@ -418,7 +452,7 @@ fn format_duration(duration: Duration) -> String {
}
}
-#[derive(Clone, Copy, Debug, Default, PartialEq)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum LogKind {
Rpc,
Trace,
@@ -435,6 +469,15 @@ impl LogKind {
LanguageServerLogType::Rpc { .. } => Self::Rpc,
}
}
+
+ fn to_proto(self) -> Option<proto::toggle_lsp_logs::LogType> {
+ match self {
+ Self::Rpc => Some(proto::toggle_lsp_logs::LogType::Rpc),
+ Self::Trace => Some(proto::toggle_lsp_logs::LogType::Trace),
+ Self::Logs => Some(proto::toggle_lsp_logs::LogType::Log),
+ Self::ServerInfo => None,
+ }
+ }
}
impl LogStore {
@@ -444,6 +487,7 @@ impl LogStore {
let log_store = Self {
projects: HashMap::default(),
language_servers: HashMap::default(),
+ next_server_generation: 0,
on_headless_host,
io_tx,
@@ -628,6 +672,7 @@ impl LogStore {
}
}
crate::Event::ToggleLspLogs {
+ peer_id,
server_id,
enabled,
toggled_log_kind,
@@ -636,7 +681,42 @@ impl LogStore {
server_kind_for_id(log_store, *server_id),
*server_id,
);
- log_store.toggle_lsp_logs(&server_key, *enabled, *toggled_log_kind);
+ log_store.set_downstream_log_stream(
+ &server_key,
+ *peer_id,
+ *toggled_log_kind,
+ *enabled,
+ cx,
+ );
+ }
+ crate::Event::CollaboratorLeft(peer_id) => {
+ log_store.release_downstream_log_streams(
+ &project.downgrade(),
+ Some(*peer_id),
+ cx,
+ );
+ }
+ crate::Event::RemoteIdChanged(None) => {
+ log_store.release_downstream_log_streams(
+ &project.downgrade(),
+ None,
+ cx,
+ );
+ }
+ crate::Event::CollaboratorUpdated {
+ old_peer_id,
+ new_peer_id,
+ } => {
+ log_store.update_downstream_peer_id(
+ &project.downgrade(),
+ *old_peer_id,
+ *new_peer_id,
+ );
+ }
+ crate::Event::Rejoined | crate::Event::HostReshared => {
+ // The host can miss a peer-ID update while offline. Synchronize on
+ // either side's return, since the guest can rejoin first.
+ log_store.synchronize_log_streams(&project.downgrade(), cx);
}
_ => {}
}
@@ -669,8 +749,11 @@ impl LogStore {
.language_servers
.entry(server_key.clone())
.or_insert_with(|| {
+ let generation = self.next_server_generation;
+ self.next_server_generation += 1;
cx.notify();
LanguageServerState {
+ generation,
name: None,
worktree_id: None,
server: server.as_ref().map(Arc::downgrade),
@@ -680,7 +763,8 @@ impl LogStore {
trace_level: TraceValue::Off,
log_level: MessageType::LOG,
io_logs_subscription: None,
- toggled_log_kind: None,
+ view_log_stream_refcounts: HashMap::default(),
+ downstream_log_streams: HashMap::default(),
}
});
@@ -910,30 +994,6 @@ impl LogStore {
.cloned()
}
- pub fn enable_rpc_trace_for_language_server(
- &mut self,
- key: &LanguageServerLogKey,
- ) -> Option<&mut LanguageServerRpcState> {
- let rpc_state = self
- .language_servers
- .get_mut(key)?
- .rpc_state
- .get_or_insert_with(|| LanguageServerRpcState {
- rpc_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
- header_state: RpcLogHeaderState::default(),
- request_tracker: RpcRequestTracker::default(),
- });
- Some(rpc_state)
- }
-
- pub fn disable_rpc_trace_for_language_server(
- &mut self,
- key: &LanguageServerLogKey,
- ) -> Option<()> {
- self.language_servers.get_mut(key)?.rpc_state.take();
- Some(())
- }
-
pub fn has_server_logs(
&self,
server: &LanguageServerSelector,
@@ -991,7 +1051,7 @@ impl LogStore {
}
.and_then(|lsp_store| lsp_store.read(cx).downstream_client());
if let Some((client, project_id)) = downstream_client {
- if state.toggled_log_kind == Some(LogKind::from_server_log_type(kind)) {
+ if state.has_downstream_log_stream(LogKind::from_server_log_type(kind)) {
client
.send(proto::LanguageServerLog {
project_id,
@@ -1009,27 +1069,184 @@ impl LogStore {
cx.emit(e);
}
- pub fn toggle_lsp_logs(
+ pub fn retain_view_log_stream(
+ &mut self,
+ key: &LanguageServerLogKey,
+ log_kind: LogKind,
+ cx: &mut Context<Self>,
+ ) -> Option<()> {
+ self.update_log_stream_ownership(
+ key,
+ log_kind,
+ |state| {
+ *state.view_log_stream_refcounts.entry(log_kind).or_default() += 1;
+ },
+ cx,
+ )
+ }
+
+ pub fn release_view_log_stream(
+ &mut self,
+ key: &LanguageServerLogKey,
+ log_kind: LogKind,
+ cx: &mut Context<Self>,
+ ) -> Option<()> {
+ self.update_log_stream_ownership(
+ key,
+ log_kind,
+ |state| match state.view_log_stream_refcounts.get_mut(&log_kind) {
+ Some(refcount) if *refcount > 1 => *refcount -= 1,
+ Some(_) => {
+ state.view_log_stream_refcounts.remove(&log_kind);
+ }
+ None => {}
+ },
+ cx,
+ )
+ }
+
+ pub fn set_downstream_log_stream(
&mut self,
key: &LanguageServerLogKey,
+ peer_id: proto::PeerId,
+ log_kind: LogKind,
enabled: bool,
- toggled_log_kind: LogKind,
+ cx: &mut Context<Self>,
+ ) -> Option<()> {
+ self.update_log_stream_ownership(
+ key,
+ log_kind,
+ |state| {
+ if enabled {
+ state
+ .downstream_log_streams
+ .entry(peer_id)
+ .or_default()
+ .insert(log_kind);
+ } else if let Some(log_kinds) = state.downstream_log_streams.get_mut(&peer_id) {
+ log_kinds.remove(&log_kind);
+ if log_kinds.is_empty() {
+ state.downstream_log_streams.remove(&peer_id);
+ }
+ }
+ },
+ cx,
+ )
+ }
+
+ fn release_downstream_log_streams(
+ &mut self,
+ project: &WeakEntity<Project>,
+ peer_id: Option<proto::PeerId>,
+ cx: &mut Context<Self>,
) {
- if let Some(server_state) = self.get_language_server_state(key) {
- if enabled {
- server_state.toggled_log_kind = Some(toggled_log_kind);
- } else {
- server_state.toggled_log_kind = None;
+ let mut streams = Vec::new();
+ for (key, state) in &self.language_servers {
+ if key.kind.project() != Some(project) {
+ continue;
+ }
+ for (downstream_peer_id, log_kinds) in &state.downstream_log_streams {
+ if peer_id.is_none_or(|peer_id| peer_id == *downstream_peer_id) {
+ streams.extend(
+ log_kinds
+ .iter()
+ .map(|log_kind| (key.clone(), *downstream_peer_id, *log_kind)),
+ );
+ }
}
}
- if toggled_log_kind == LogKind::Rpc {
- if enabled {
- self.enable_rpc_trace_for_language_server(key);
- } else {
- self.disable_rpc_trace_for_language_server(key);
+
+ for (key, peer_id, log_kind) in streams {
+ self.set_downstream_log_stream(&key, peer_id, log_kind, false, cx);
+ }
+ }
+
+ fn update_downstream_peer_id(
+ &mut self,
+ project: &WeakEntity<Project>,
+ old_peer_id: proto::PeerId,
+ new_peer_id: proto::PeerId,
+ ) {
+ for (key, state) in &mut self.language_servers {
+ if key.kind.project() == Some(project)
+ && let Some(log_kinds) = state.downstream_log_streams.remove(&old_peer_id)
+ {
+ state
+ .downstream_log_streams
+ .entry(new_peer_id)
+ .or_default()
+ .extend(log_kinds);
+ }
+ }
+ }
+
+ fn update_log_stream_ownership(
+ &mut self,
+ key: &LanguageServerLogKey,
+ log_kind: LogKind,
+ update: impl FnOnce(&mut LanguageServerState),
+ cx: &mut Context<Self>,
+ ) -> Option<()> {
+ let (was_enabled, is_enabled) = {
+ let state = self.get_language_server_state(key)?;
+ let was_enabled = state.has_log_stream(log_kind);
+ update(state);
+ let is_enabled = state.has_log_stream(log_kind);
+ if log_kind == LogKind::Rpc {
+ state.synchronize_rpc_state();
+ }
+ (was_enabled, is_enabled)
+ };
+
+ if was_enabled != is_enabled {
+ Self::send_toggle_log_message(key, is_enabled, log_kind, cx);
+ }
+ Some(())
+ }
+
+ fn synchronize_log_streams(&self, project: &WeakEntity<Project>, cx: &mut App) {
+ for (key, state) in &self.language_servers {
+ if !matches!(&key.kind, LanguageServerKind::Remote { project: server_project } if server_project == project)
+ {
+ continue;
+ }
+ // Disables sent while disconnected were lost, but the host may have
+ // migrated those obsolete subscriptions to our new peer ID.
+ for log_kind in [LogKind::Logs, LogKind::Trace, LogKind::Rpc] {
+ Self::send_toggle_log_message(key, state.has_log_stream(log_kind), log_kind, cx);
}
}
}
+
+ fn send_toggle_log_message(
+ key: &LanguageServerLogKey,
+ enabled: bool,
+ log_kind: LogKind,
+ cx: &mut App,
+ ) {
+ let LanguageServerKind::Remote { project } = &key.kind else {
+ return;
+ };
+ let Some(log_type) = log_kind.to_proto() else {
+ return;
+ };
+ let Some(project) = project.upgrade() else {
+ return;
+ };
+ let lsp_store = project.read(cx).lsp_store();
+ let Some((client, project_id)) = lsp_store.read(cx).upstream_client() else {
+ return;
+ };
+ client
+ .send(proto::ToggleLspLogs {
+ project_id,
+ log_type: log_type as i32,
+ server_id: key.server_id.to_proto(),
+ enabled,
+ })
+ .log_err();
+ }
+
pub fn sync_copilot_for_project(
&mut self,
project: &WeakEntity<Project>,
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 2bdff41b16f..ae264f3a0e6 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -350,6 +350,7 @@ pub enum Event {
name: Option<LanguageServerName>,
},
ToggleLspLogs {
+ peer_id: proto::PeerId,
server_id: LanguageServerId,
enabled: bool,
toggled_log_kind: LogKind,
@@ -5883,6 +5884,7 @@ impl Project {
envelope: TypedEnvelope<proto::ToggleLspLogs>,
mut cx: AsyncApp,
) -> Result<()> {
+ let peer_id = envelope.original_sender_id()?;
let toggled_log_kind =
match proto::toggle_lsp_logs::LogType::try_from(envelope.payload.log_type)
.ok()
@@ -5894,6 +5896,7 @@ impl Project {
};
project.update(&mut cx, |_, cx| {
cx.emit(Event::ToggleLspLogs {
+ peer_id,
server_id: LanguageServerId::from_proto(envelope.payload.server_id),
enabled: envelope.payload.enabled,
toggled_log_kind,
diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rs
index b4d2a48a6fd..9219da198e6 100644
--- a/crates/proto/src/proto.rs
+++ b/crates/proto/src/proto.rs
@@ -395,7 +395,8 @@ messages!(
(LoadCommitTemplateResponse, Background),
(GitClone, Background),
(GitCloneResponse, Background),
- (ToggleLspLogs, Background),
+ // Reconnect reconciliation must stay ordered with subsequent user toggles.
+ (ToggleLspLogs, Foreground),
(GetDirectoryEnvironment, Background),
(DirectoryEnvironment, Background),
(GetAgentServerCommand, Background),
@@ -648,7 +649,6 @@ request_messages!(
(LoadCommitTemplate, LoadCommitTemplateResponse),
(GetTreeDiff, GetTreeDiffResponse),
(GitClone, GitCloneResponse),
- (ToggleLspLogs, Ack),
(GetDirectoryEnvironment, DirectoryEnvironment),
(GetProcesses, GetProcessesResponse),
(GetAgentServerCommand, AgentServerCommand),
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 0a6905362e7..068588a6c25 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -900,6 +900,7 @@ impl HeadlessProject {
envelope: TypedEnvelope<proto::ToggleLspLogs>,
cx: AsyncApp,
) -> Result<()> {
+ let peer_id = envelope.original_sender_id.unwrap_or(envelope.sender_id);
let server_id = LanguageServerId::from_proto(envelope.payload.server_id);
let lsp_store = this.read_with(&cx, |this, _| this.lsp_store.downgrade());
cx.update(|cx| {
@@ -918,8 +919,14 @@ impl HeadlessProject {
};
let server_key =
LanguageServerLogKey::new(LanguageServerKind::LocalSsh { lsp_store }, server_id);
- log_store.update(cx, |log_store, _| {
- log_store.toggle_lsp_logs(&server_key, envelope.payload.enabled, toggled_log_kind);
+ log_store.update(cx, |log_store, cx| {
+ log_store.set_downstream_log_stream(
+ &server_key,
+ peer_id,
+ toggled_log_kind,
+ envelope.payload.enabled,
+ cx,
+ );
});
anyhow::Ok(())
})?;
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index dc99eb5df6f..ef65cc6fbc8 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -43,7 +43,9 @@ use project::{
CompletionSource, LanguageServerLogType, ProgressToken, Project, ProjectPath,
agent_server_store::AgentServerCommand,
image_store,
- lsp_store::log_store::{LanguageServerKind, LanguageServerLogKey, LogStore},
+ lsp_store::log_store::{
+ GlobalLogStore, LanguageServerKind, LanguageServerLogKey, LogKind, LogStore,
+ },
search::{SearchQuery, SearchResult},
};
use remote::{ConnectionState, RemoteClient, RemoteClientEvent};
@@ -5287,6 +5289,284 @@ async fn test_remote_project_creation_notifies_new_entity_observers(
assert!(project.read_with(cx, |project, _| project.is_remote()));
}
+#[gpui::test]
+async fn test_remote_log_streams_follow_aggregate_demand(
+ cx: &mut TestAppContext,
+ server_cx: &mut TestAppContext,
+) {
+ let server_fs = Arc::new(FakeFs::new(server_cx.executor()));
+ server_fs
+ .insert_tree(path!("/code"), json!({ "project1": { "README.md": "" } }))
+ .await;
+ let (project, headless) = init_test(&server_fs, cx, server_cx).await;
+
+ let server_id = LanguageServerId(42);
+ let remote_server_key = LanguageServerLogKey::new(
+ LanguageServerKind::Remote {
+ project: project.downgrade(),
+ },
+ server_id,
+ );
+ let local_log_store = cx.new(|cx| LogStore::new(false, cx));
+ local_log_store.update(cx, |log_store, cx| {
+ log_store.add_project(&project, cx);
+ log_store.add_language_server(
+ remote_server_key.kind.clone(),
+ server_id,
+ Some(LanguageServerName::new_static("test-server")),
+ None,
+ None,
+ cx,
+ );
+ });
+
+ let headless_lsp_store =
+ headless.read_with(server_cx, |headless, _| headless.lsp_store.downgrade());
+ let headless_server_key = LanguageServerLogKey::new(
+ LanguageServerKind::LocalSsh {
+ lsp_store: headless_lsp_store,
+ },
+ server_id,
+ );
+ let headless_log_store = server_cx.update(|cx| cx.global::<GlobalLogStore>().0.clone());
+ headless_log_store.update(server_cx, |log_store, cx| {
+ log_store.add_language_server(
+ headless_server_key.kind.clone(),
+ server_id,
+ Some(LanguageServerName::new_static("test-server")),
+ None,
+ None,
+ cx,
+ );
+ });
+
+ let peer_id = proto::PeerId { owner_id: 1, id: 1 };
+ local_log_store.update(cx, |log_store, cx| {
+ log_store.retain_view_log_stream(&remote_server_key, LogKind::Rpc, cx);
+ });
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ }));
+
+ project.update(cx, |_, cx| {
+ cx.emit(project::Event::ToggleLspLogs {
+ peer_id,
+ server_id,
+ enabled: true,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ local_log_store.update(cx, |log_store, cx| {
+ log_store.release_view_log_stream(&remote_server_key, LogKind::Rpc, cx);
+ });
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(
+ headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ }),
+ "releasing a local view must preserve downstream demand on the remote host"
+ );
+
+ let other_project = Project::test(FakeFs::new(cx.executor()), [], cx).await;
+ local_log_store.update(cx, |log_store, cx| {
+ log_store.add_project(&other_project, cx);
+ });
+ for event in [project::Event::Rejoined, project::Event::HostReshared] {
+ // Forget upstream ownership without changing the remaining downstream demand.
+ headless_log_store.update(server_cx, |log_store, cx| {
+ assert!(
+ log_store
+ .language_servers
+ .remove(&headless_server_key)
+ .is_some()
+ );
+ log_store.add_language_server(
+ headless_server_key.kind.clone(),
+ server_id,
+ None,
+ None,
+ None,
+ cx,
+ );
+ });
+ other_project.update(cx, |_, cx| cx.emit(event.clone()));
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(
+ headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_none())
+ }),
+ "reconnecting another project must not replay this project's streams"
+ );
+
+ for _ in 0..2 {
+ project.update(cx, |_, cx| cx.emit(event.clone()));
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(
+ headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ }),
+ "{event:?} must replay downstream-only demand without a local view"
+ );
+ }
+ }
+
+ project.update(cx, |_, cx| {
+ cx.emit(project::Event::CollaboratorLeft(peer_id));
+ });
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_none())
+ }));
+
+ project.update(cx, |_, cx| {
+ cx.emit(project::Event::ToggleLspLogs {
+ peer_id,
+ server_id,
+ enabled: true,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(
+ headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ }),
+ "downstream demand must enable the stream on the remote host"
+ );
+
+ local_log_store.update(cx, |log_store, cx| {
+ log_store.retain_view_log_stream(&remote_server_key, LogKind::Rpc, cx);
+ });
+ project.update(cx, |_, cx| {
+ cx.emit(project::Event::ToggleLspLogs {
+ peer_id,
+ server_id,
+ enabled: false,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(
+ headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ }),
+ "releasing downstream demand must preserve a local view on the remote host"
+ );
+
+ local_log_store.update(cx, |log_store, cx| {
+ log_store.release_view_log_stream(&remote_server_key, LogKind::Rpc, cx);
+ });
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_none())
+ }));
+ project.update(cx, |_, cx| {
+ cx.emit(project::Event::Rejoined);
+ cx.emit(project::Event::HostReshared);
+ });
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(
+ headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_none())
+ }),
+ "reconnecting must not replay streams without any remaining demand"
+ );
+
+ for has_local_view in [false, true] {
+ project
+ .update(cx, |project, cx| project.shared(1, cx))
+ .expect("project should be shareable");
+ if has_local_view {
+ local_log_store.update(cx, |log_store, cx| {
+ log_store.retain_view_log_stream(&remote_server_key, LogKind::Rpc, cx);
+ });
+ }
+ project.update(cx, |_, cx| {
+ cx.emit(project::Event::ToggleLspLogs {
+ peer_id,
+ server_id,
+ enabled: true,
+ toggled_log_kind: LogKind::Rpc,
+ });
+ });
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_some())
+ }));
+
+ project
+ .update(cx, |project, cx| project.unshare(cx))
+ .expect("shared project should unshare");
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert_eq!(
+ headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .map(|state| state.rpc_state.is_some())
+ }),
+ Some(has_local_view),
+ "unsharing must release downstream demand while preserving local views"
+ );
+
+ if has_local_view {
+ local_log_store.update(cx, |log_store, cx| {
+ log_store.release_view_log_stream(&remote_server_key, LogKind::Rpc, cx);
+ });
+ cx.run_until_parked();
+ server_cx.run_until_parked();
+ assert!(headless_log_store.read_with(server_cx, |log_store, _| {
+ log_store
+ .language_servers
+ .get(&headless_server_key)
+ .is_some_and(|state| state.rpc_state.is_none())
+ }));
+ }
+ }
+}
+
#[gpui::test]
async fn test_log_store_keys_remote_events_by_primary_kind_on_supplementary_id_collision(
cx: &mut TestAppContext,