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.rsindex 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 @@ whereOk(())}+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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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,