1use collections::{HashMap, VecDeque};
2use editor::{actions::MoveToEnd, Editor, EditorEvent};
3use futures::{channel::mpsc, StreamExt};
4use gpui::{
5 actions, div, AnchorCorner, AnyElement, AppContext, Context, EventEmitter, FocusHandle,
6 FocusableView, IntoElement, Model, ModelContext, ParentElement, Render, Styled, Subscription,
7 View, ViewContext, VisualContext, WeakModel, WindowContext,
8};
9use language::{LanguageServerId, LanguageServerName};
10use lsp::IoKind;
11use project::{search::SearchQuery, Project};
12use std::{borrow::Cow, sync::Arc};
13use ui::{popover_menu, prelude::*, Button, Checkbox, ContextMenu, Label, Selection};
14use workspace::{
15 item::{Item, ItemHandle},
16 searchable::{SearchEvent, SearchableItem, SearchableItemHandle},
17 ToolbarItemEvent, ToolbarItemLocation, ToolbarItemView, Workspace,
18};
19
20const SEND_LINE: &str = "// Send:";
21const RECEIVE_LINE: &str = "// Receive:";
22const MAX_STORED_LOG_ENTRIES: usize = 2000;
23
24pub struct LogStore {
25 projects: HashMap<WeakModel<Project>, ProjectState>,
26 io_tx: mpsc::UnboundedSender<(WeakModel<Project>, LanguageServerId, IoKind, String)>,
27}
28
29struct ProjectState {
30 servers: HashMap<LanguageServerId, LanguageServerState>,
31 _subscriptions: [gpui::Subscription; 2],
32}
33
34struct LanguageServerState {
35 log_messages: VecDeque<String>,
36 rpc_state: Option<LanguageServerRpcState>,
37 _io_logs_subscription: Option<lsp::Subscription>,
38 _lsp_logs_subscription: Option<lsp::Subscription>,
39}
40
41struct LanguageServerRpcState {
42 rpc_messages: VecDeque<String>,
43 last_message_kind: Option<MessageKind>,
44}
45
46pub struct LspLogView {
47 pub(crate) editor: View<Editor>,
48 editor_subscriptions: Vec<Subscription>,
49 log_store: Model<LogStore>,
50 current_server_id: Option<LanguageServerId>,
51 is_showing_rpc_trace: bool,
52 project: Model<Project>,
53 focus_handle: FocusHandle,
54 _log_store_subscriptions: Vec<Subscription>,
55}
56
57pub struct LspLogToolbarItemView {
58 log_view: Option<View<LspLogView>>,
59 _log_view_subscription: Option<Subscription>,
60}
61
62#[derive(Copy, Clone, PartialEq, Eq)]
63enum MessageKind {
64 Send,
65 Receive,
66}
67
68#[derive(Clone, Debug, PartialEq)]
69pub(crate) struct LogMenuItem {
70 pub server_id: LanguageServerId,
71 pub server_name: LanguageServerName,
72 pub worktree_root_name: String,
73 pub rpc_trace_enabled: bool,
74 pub rpc_trace_selected: bool,
75 pub logs_selected: bool,
76}
77
78actions!(debug, [OpenLanguageServerLogs]);
79
80pub fn init(cx: &mut AppContext) {
81 let log_store = cx.new_model(|cx| LogStore::new(cx));
82
83 cx.observe_new_views(move |workspace: &mut Workspace, cx| {
84 let project = workspace.project();
85 if project.read(cx).is_local() {
86 log_store.update(cx, |store, cx| {
87 store.add_project(&project, cx);
88 });
89 }
90
91 let log_store = log_store.clone();
92 workspace.register_action(move |workspace, _: &OpenLanguageServerLogs, cx| {
93 let project = workspace.project().read(cx);
94 if project.is_local() {
95 workspace.add_item(
96 Box::new(cx.new_view(|cx| {
97 LspLogView::new(workspace.project().clone(), log_store.clone(), cx)
98 })),
99 cx,
100 );
101 }
102 });
103 })
104 .detach();
105}
106
107impl LogStore {
108 pub fn new(cx: &mut ModelContext<Self>) -> Self {
109 let (io_tx, mut io_rx) = mpsc::unbounded();
110 let this = Self {
111 projects: HashMap::default(),
112 io_tx,
113 };
114 cx.spawn(|this, mut cx| async move {
115 while let Some((project, server_id, io_kind, message)) = io_rx.next().await {
116 if let Some(this) = this.upgrade() {
117 this.update(&mut cx, |this, cx| {
118 this.on_io(project, server_id, io_kind, &message, cx);
119 })?;
120 }
121 }
122 anyhow::Ok(())
123 })
124 .detach_and_log_err(cx);
125 this
126 }
127
128 pub fn add_project(&mut self, project: &Model<Project>, cx: &mut ModelContext<Self>) {
129 let weak_project = project.downgrade();
130 self.projects.insert(
131 project.downgrade(),
132 ProjectState {
133 servers: HashMap::default(),
134 _subscriptions: [
135 cx.observe_release(project, move |this, _, _| {
136 this.projects.remove(&weak_project);
137 }),
138 cx.subscribe(project, |this, project, event, cx| match event {
139 project::Event::LanguageServerAdded(id) => {
140 this.add_language_server(&project, *id, cx);
141 }
142 project::Event::LanguageServerRemoved(id) => {
143 this.remove_language_server(&project, *id, cx);
144 }
145 project::Event::LanguageServerLog(id, message) => {
146 this.add_language_server_log(&project, *id, message, cx);
147 }
148 _ => {}
149 }),
150 ],
151 },
152 );
153 }
154
155 fn add_language_server(
156 &mut self,
157 project: &Model<Project>,
158 id: LanguageServerId,
159 cx: &mut ModelContext<Self>,
160 ) -> Option<&mut LanguageServerState> {
161 let project_state = self.projects.get_mut(&project.downgrade())?;
162 let server_state = project_state.servers.entry(id).or_insert_with(|| {
163 cx.notify();
164 LanguageServerState {
165 rpc_state: None,
166 log_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
167 _io_logs_subscription: None,
168 _lsp_logs_subscription: None,
169 }
170 });
171
172 let server = project.read(cx).language_server_for_id(id);
173 if let Some(server) = server.as_deref() {
174 if server.has_notification_handler::<lsp::notification::LogMessage>() {
175 // Another event wants to re-add the server that was already added and subscribed to, avoid doing it again.
176 return Some(server_state);
177 }
178 }
179
180 let weak_project = project.downgrade();
181 let io_tx = self.io_tx.clone();
182 server_state._io_logs_subscription = server.as_ref().map(|server| {
183 server.on_io(move |io_kind, message| {
184 io_tx
185 .unbounded_send((weak_project.clone(), id, io_kind, message.to_string()))
186 .ok();
187 })
188 });
189 let this = cx.handle().downgrade();
190 let weak_project = project.downgrade();
191 server_state._lsp_logs_subscription = server.map(|server| {
192 let server_id = server.server_id();
193 server.on_notification::<lsp::notification::LogMessage, _>({
194 move |params, mut cx| {
195 if let Some((project, this)) = weak_project.upgrade().zip(this.upgrade()) {
196 this.update(&mut cx, |this, cx| {
197 this.add_language_server_log(&project, server_id, ¶ms.message, cx);
198 })
199 .ok();
200 }
201 }
202 })
203 });
204 Some(server_state)
205 }
206
207 fn add_language_server_log(
208 &mut self,
209 project: &Model<Project>,
210 id: LanguageServerId,
211 message: &str,
212 cx: &mut ModelContext<Self>,
213 ) -> Option<()> {
214 let language_server_state = match self
215 .projects
216 .get_mut(&project.downgrade())?
217 .servers
218 .get_mut(&id)
219 {
220 Some(existing_state) => existing_state,
221 None => self.add_language_server(&project, id, cx)?,
222 };
223
224 let log_lines = &mut language_server_state.log_messages;
225 while log_lines.len() >= MAX_STORED_LOG_ENTRIES {
226 log_lines.pop_front();
227 }
228 let message = message.trim();
229 log_lines.push_back(message.to_string());
230 cx.emit(Event::NewServerLogEntry {
231 id,
232 entry: message.to_string(),
233 is_rpc: false,
234 });
235 cx.notify();
236 Some(())
237 }
238
239 fn remove_language_server(
240 &mut self,
241 project: &Model<Project>,
242 id: LanguageServerId,
243 cx: &mut ModelContext<Self>,
244 ) -> Option<()> {
245 let project_state = self.projects.get_mut(&project.downgrade())?;
246 project_state.servers.remove(&id);
247 cx.notify();
248 Some(())
249 }
250
251 fn server_logs(
252 &self,
253 project: &Model<Project>,
254 server_id: LanguageServerId,
255 ) -> Option<&VecDeque<String>> {
256 let weak_project = project.downgrade();
257 let project_state = self.projects.get(&weak_project)?;
258 let server_state = project_state.servers.get(&server_id)?;
259 Some(&server_state.log_messages)
260 }
261
262 fn enable_rpc_trace_for_language_server(
263 &mut self,
264 project: &Model<Project>,
265 server_id: LanguageServerId,
266 ) -> Option<&mut LanguageServerRpcState> {
267 let weak_project = project.downgrade();
268 let project_state = self.projects.get_mut(&weak_project)?;
269 let server_state = project_state.servers.get_mut(&server_id)?;
270 let rpc_state = server_state
271 .rpc_state
272 .get_or_insert_with(|| LanguageServerRpcState {
273 rpc_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
274 last_message_kind: None,
275 });
276 Some(rpc_state)
277 }
278
279 pub fn disable_rpc_trace_for_language_server(
280 &mut self,
281 project: &Model<Project>,
282 server_id: LanguageServerId,
283 _: &mut ModelContext<Self>,
284 ) -> Option<()> {
285 let project = project.downgrade();
286 let project_state = self.projects.get_mut(&project)?;
287 let server_state = project_state.servers.get_mut(&server_id)?;
288 server_state.rpc_state.take();
289 Some(())
290 }
291
292 fn on_io(
293 &mut self,
294 project: WeakModel<Project>,
295 language_server_id: LanguageServerId,
296 io_kind: IoKind,
297 message: &str,
298 cx: &mut ModelContext<Self>,
299 ) -> Option<()> {
300 let is_received = match io_kind {
301 IoKind::StdOut => true,
302 IoKind::StdIn => false,
303 IoKind::StdErr => {
304 let project = project.upgrade()?;
305 let message = format!("stderr: {}", message.trim());
306 self.add_language_server_log(&project, language_server_id, &message, cx);
307 return Some(());
308 }
309 };
310
311 let state = self
312 .projects
313 .get_mut(&project)?
314 .servers
315 .get_mut(&language_server_id)?
316 .rpc_state
317 .as_mut()?;
318 let kind = if is_received {
319 MessageKind::Receive
320 } else {
321 MessageKind::Send
322 };
323
324 let rpc_log_lines = &mut state.rpc_messages;
325 if state.last_message_kind != Some(kind) {
326 let line_before_message = match kind {
327 MessageKind::Send => SEND_LINE,
328 MessageKind::Receive => RECEIVE_LINE,
329 };
330 rpc_log_lines.push_back(line_before_message.to_string());
331 cx.emit(Event::NewServerLogEntry {
332 id: language_server_id,
333 entry: line_before_message.to_string(),
334 is_rpc: true,
335 });
336 }
337
338 while rpc_log_lines.len() >= MAX_STORED_LOG_ENTRIES {
339 rpc_log_lines.pop_front();
340 }
341 let message = message.trim();
342 rpc_log_lines.push_back(message.to_string());
343 cx.emit(Event::NewServerLogEntry {
344 id: language_server_id,
345 entry: message.to_string(),
346 is_rpc: true,
347 });
348 cx.notify();
349 Some(())
350 }
351}
352
353impl LspLogView {
354 pub fn new(
355 project: Model<Project>,
356 log_store: Model<LogStore>,
357 cx: &mut ViewContext<Self>,
358 ) -> Self {
359 let server_id = log_store
360 .read(cx)
361 .projects
362 .get(&project.downgrade())
363 .and_then(|project| project.servers.keys().copied().next());
364 let model_changes_subscription = cx.observe(&log_store, |this, store, cx| {
365 (|| -> Option<()> {
366 let project_state = store.read(cx).projects.get(&this.project.downgrade())?;
367 if let Some(current_lsp) = this.current_server_id {
368 if !project_state.servers.contains_key(¤t_lsp) {
369 if let Some(server) = project_state.servers.iter().next() {
370 if this.is_showing_rpc_trace {
371 this.show_rpc_trace_for_server(*server.0, cx)
372 } else {
373 this.show_logs_for_server(*server.0, cx)
374 }
375 } else {
376 this.current_server_id = None;
377 this.editor.update(cx, |editor, cx| {
378 editor.set_read_only(false);
379 editor.clear(cx);
380 editor.set_read_only(true);
381 });
382 cx.notify();
383 }
384 }
385 } else {
386 if let Some(server) = project_state.servers.iter().next() {
387 if this.is_showing_rpc_trace {
388 this.show_rpc_trace_for_server(*server.0, cx)
389 } else {
390 this.show_logs_for_server(*server.0, cx)
391 }
392 }
393 }
394
395 Some(())
396 })();
397
398 cx.notify();
399 });
400 let events_subscriptions = cx.subscribe(&log_store, |log_view, _, e, cx| match e {
401 Event::NewServerLogEntry { id, entry, is_rpc } => {
402 if log_view.current_server_id == Some(*id) {
403 if (*is_rpc && log_view.is_showing_rpc_trace)
404 || (!*is_rpc && !log_view.is_showing_rpc_trace)
405 {
406 log_view.editor.update(cx, |editor, cx| {
407 editor.set_read_only(false);
408 let last_point = editor.buffer().read(cx).len(cx);
409 editor.edit(
410 vec![
411 (last_point..last_point, entry.trim()),
412 (last_point..last_point, "\n"),
413 ],
414 cx,
415 );
416 editor.set_read_only(true);
417 });
418 }
419 }
420 }
421 });
422 let (editor, editor_subscriptions) = Self::editor_for_logs(String::new(), cx);
423
424 let focus_handle = cx.focus_handle();
425 let focus_subscription = cx.on_focus(&focus_handle, |log_view, cx| {
426 cx.focus_view(&log_view.editor);
427 });
428
429 let mut this = Self {
430 focus_handle,
431 editor,
432 editor_subscriptions,
433 project,
434 log_store,
435 current_server_id: None,
436 is_showing_rpc_trace: false,
437 _log_store_subscriptions: vec![
438 model_changes_subscription,
439 events_subscriptions,
440 focus_subscription,
441 ],
442 };
443 if let Some(server_id) = server_id {
444 this.show_logs_for_server(server_id, cx);
445 }
446 this
447 }
448
449 fn editor_for_logs(
450 log_contents: String,
451 cx: &mut ViewContext<Self>,
452 ) -> (View<Editor>, Vec<Subscription>) {
453 let editor = cx.new_view(|cx| {
454 let mut editor = Editor::multi_line(cx);
455 editor.set_text(log_contents, cx);
456 editor.move_to_end(&MoveToEnd, cx);
457 editor.set_read_only(true);
458 editor.set_show_copilot_suggestions(false);
459 editor
460 });
461 let editor_subscription = cx.subscribe(
462 &editor,
463 |_, _, event: &EditorEvent, cx: &mut ViewContext<'_, LspLogView>| {
464 cx.emit(event.clone())
465 },
466 );
467 let search_subscription = cx.subscribe(
468 &editor,
469 |_, _, event: &SearchEvent, cx: &mut ViewContext<'_, LspLogView>| {
470 cx.emit(event.clone())
471 },
472 );
473 (editor, vec![editor_subscription, search_subscription])
474 }
475
476 pub(crate) fn menu_items<'a>(&'a self, cx: &'a AppContext) -> Option<Vec<LogMenuItem>> {
477 let log_store = self.log_store.read(cx);
478 let state = log_store.projects.get(&self.project.downgrade())?;
479 let mut rows = self
480 .project
481 .read(cx)
482 .language_servers()
483 .filter_map(|(server_id, language_server_name, worktree_id)| {
484 let worktree = self.project.read(cx).worktree_for_id(worktree_id, cx)?;
485 let state = state.servers.get(&server_id)?;
486 Some(LogMenuItem {
487 server_id,
488 server_name: language_server_name,
489 worktree_root_name: worktree.read(cx).root_name().to_string(),
490 rpc_trace_enabled: state.rpc_state.is_some(),
491 rpc_trace_selected: self.is_showing_rpc_trace
492 && self.current_server_id == Some(server_id),
493 logs_selected: !self.is_showing_rpc_trace
494 && self.current_server_id == Some(server_id),
495 })
496 })
497 .chain(
498 self.project
499 .read(cx)
500 .supplementary_language_servers()
501 .filter_map(|(&server_id, (name, _))| {
502 let state = state.servers.get(&server_id)?;
503 Some(LogMenuItem {
504 server_id,
505 server_name: name.clone(),
506 worktree_root_name: "supplementary".to_string(),
507 rpc_trace_enabled: state.rpc_state.is_some(),
508 rpc_trace_selected: self.is_showing_rpc_trace
509 && self.current_server_id == Some(server_id),
510 logs_selected: !self.is_showing_rpc_trace
511 && self.current_server_id == Some(server_id),
512 })
513 }),
514 )
515 .collect::<Vec<_>>();
516 rows.sort_by_key(|row| row.server_id);
517 rows.dedup_by_key(|row| row.server_id);
518 Some(rows)
519 }
520
521 fn show_logs_for_server(&mut self, server_id: LanguageServerId, cx: &mut ViewContext<Self>) {
522 let log_contents = self
523 .log_store
524 .read(cx)
525 .server_logs(&self.project, server_id)
526 .map(log_contents);
527 if let Some(log_contents) = log_contents {
528 self.current_server_id = Some(server_id);
529 self.is_showing_rpc_trace = false;
530 let (editor, editor_subscriptions) = Self::editor_for_logs(log_contents, cx);
531 self.editor = editor;
532 self.editor_subscriptions = editor_subscriptions;
533 cx.notify();
534 }
535 cx.focus(&self.focus_handle);
536 }
537
538 fn show_rpc_trace_for_server(
539 &mut self,
540 server_id: LanguageServerId,
541 cx: &mut ViewContext<Self>,
542 ) {
543 let rpc_log = self.log_store.update(cx, |log_store, _| {
544 log_store
545 .enable_rpc_trace_for_language_server(&self.project, server_id)
546 .map(|state| log_contents(&state.rpc_messages))
547 });
548 if let Some(rpc_log) = rpc_log {
549 self.current_server_id = Some(server_id);
550 self.is_showing_rpc_trace = true;
551 let (editor, editor_subscriptions) = Self::editor_for_logs(rpc_log, cx);
552 let language = self.project.read(cx).languages().language_for_name("JSON");
553 editor
554 .read(cx)
555 .buffer()
556 .read(cx)
557 .as_singleton()
558 .expect("log buffer should be a singleton")
559 .update(cx, |_, cx| {
560 cx.spawn({
561 let buffer = cx.handle();
562 |_, mut cx| async move {
563 let language = language.await.ok();
564 buffer.update(&mut cx, |buffer, cx| {
565 buffer.set_language(language, cx);
566 })
567 }
568 })
569 .detach_and_log_err(cx);
570 });
571
572 self.editor = editor;
573 self.editor_subscriptions = editor_subscriptions;
574 cx.notify();
575 }
576
577 cx.focus(&self.focus_handle);
578 }
579
580 fn toggle_rpc_trace_for_server(
581 &mut self,
582 server_id: LanguageServerId,
583 enabled: bool,
584 cx: &mut ViewContext<Self>,
585 ) {
586 self.log_store.update(cx, |log_store, cx| {
587 if enabled {
588 log_store.enable_rpc_trace_for_language_server(&self.project, server_id);
589 } else {
590 log_store.disable_rpc_trace_for_language_server(&self.project, server_id, cx);
591 }
592 });
593 if !enabled && Some(server_id) == self.current_server_id {
594 self.show_logs_for_server(server_id, cx);
595 cx.notify();
596 }
597 }
598}
599
600fn log_contents(lines: &VecDeque<String>) -> String {
601 let (a, b) = lines.as_slices();
602 let log_contents = a.join("\n");
603 if b.is_empty() {
604 log_contents
605 } else {
606 log_contents + "\n" + &b.join("\n")
607 }
608}
609
610impl Render for LspLogView {
611 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
612 self.editor
613 .update(cx, |editor, cx| editor.render(cx).into_any_element())
614 }
615}
616
617impl FocusableView for LspLogView {
618 fn focus_handle(&self, _: &AppContext) -> FocusHandle {
619 self.focus_handle.clone()
620 }
621}
622
623impl Item for LspLogView {
624 type Event = EditorEvent;
625
626 fn to_item_events(event: &Self::Event, f: impl FnMut(workspace::item::ItemEvent)) {
627 Editor::to_item_events(event, f)
628 }
629
630 fn tab_content(&self, _: Option<usize>, selected: bool, _: &WindowContext<'_>) -> AnyElement {
631 Label::new("LSP Logs")
632 .color(if selected {
633 Color::Default
634 } else {
635 Color::Muted
636 })
637 .into_any_element()
638 }
639
640 fn telemetry_event_text(&self) -> Option<&'static str> {
641 None
642 }
643
644 fn as_searchable(&self, handle: &View<Self>) -> Option<Box<dyn SearchableItemHandle>> {
645 Some(Box::new(handle.clone()))
646 }
647}
648
649impl SearchableItem for LspLogView {
650 type Match = <Editor as SearchableItem>::Match;
651
652 fn clear_matches(&mut self, cx: &mut ViewContext<Self>) {
653 self.editor.update(cx, |e, cx| e.clear_matches(cx))
654 }
655
656 fn update_matches(&mut self, matches: Vec<Self::Match>, cx: &mut ViewContext<Self>) {
657 self.editor
658 .update(cx, |e, cx| e.update_matches(matches, cx))
659 }
660
661 fn query_suggestion(&mut self, cx: &mut ViewContext<Self>) -> String {
662 self.editor.update(cx, |e, cx| e.query_suggestion(cx))
663 }
664
665 fn activate_match(
666 &mut self,
667 index: usize,
668 matches: Vec<Self::Match>,
669 cx: &mut ViewContext<Self>,
670 ) {
671 self.editor
672 .update(cx, |e, cx| e.activate_match(index, matches, cx))
673 }
674
675 fn select_matches(&mut self, matches: Vec<Self::Match>, cx: &mut ViewContext<Self>) {
676 self.editor
677 .update(cx, |e, cx| e.select_matches(matches, cx))
678 }
679
680 fn find_matches(
681 &mut self,
682 query: Arc<project::search::SearchQuery>,
683 cx: &mut ViewContext<Self>,
684 ) -> gpui::Task<Vec<Self::Match>> {
685 self.editor.update(cx, |e, cx| e.find_matches(query, cx))
686 }
687
688 fn replace(&mut self, _: &Self::Match, _: &SearchQuery, _: &mut ViewContext<Self>) {
689 // Since LSP Log is read-only, it doesn't make sense to support replace operation.
690 }
691 fn supported_options() -> workspace::searchable::SearchOptions {
692 workspace::searchable::SearchOptions {
693 case: true,
694 word: true,
695 regex: true,
696 // LSP log is read-only.
697 replacement: false,
698 }
699 }
700 fn active_match_index(
701 &mut self,
702 matches: Vec<Self::Match>,
703 cx: &mut ViewContext<Self>,
704 ) -> Option<usize> {
705 self.editor
706 .update(cx, |e, cx| e.active_match_index(matches, cx))
707 }
708}
709
710impl EventEmitter<ToolbarItemEvent> for LspLogToolbarItemView {}
711
712impl ToolbarItemView for LspLogToolbarItemView {
713 fn set_active_pane_item(
714 &mut self,
715 active_pane_item: Option<&dyn ItemHandle>,
716 cx: &mut ViewContext<Self>,
717 ) -> workspace::ToolbarItemLocation {
718 if let Some(item) = active_pane_item {
719 if let Some(log_view) = item.downcast::<LspLogView>() {
720 self.log_view = Some(log_view.clone());
721 self._log_view_subscription = Some(cx.observe(&log_view, |_, _, cx| {
722 cx.notify();
723 }));
724 return ToolbarItemLocation::PrimaryLeft;
725 }
726 }
727 self.log_view = None;
728 self._log_view_subscription = None;
729 ToolbarItemLocation::Hidden
730 }
731}
732
733impl Render for LspLogToolbarItemView {
734 fn render(&mut self, cx: &mut ViewContext<Self>) -> impl IntoElement {
735 let Some(log_view) = self.log_view.clone() else {
736 return div();
737 };
738 let (menu_rows, current_server_id) = log_view.update(cx, |log_view, cx| {
739 let menu_rows = log_view.menu_items(cx).unwrap_or_default();
740 let current_server_id = log_view.current_server_id;
741 (menu_rows, current_server_id)
742 });
743
744 let current_server = current_server_id.and_then(|current_server_id| {
745 if let Ok(ix) = menu_rows.binary_search_by_key(¤t_server_id, |e| e.server_id) {
746 Some(menu_rows[ix].clone())
747 } else {
748 None
749 }
750 });
751
752 let log_toolbar_view = cx.view().clone();
753 let lsp_menu = popover_menu("LspLogView")
754 .anchor(AnchorCorner::TopLeft)
755 .trigger(Button::new(
756 "language_server_menu_header",
757 current_server
758 .and_then(|row| {
759 Some(Cow::Owned(format!(
760 "{} ({}) - {}",
761 row.server_name.0,
762 row.worktree_root_name,
763 if row.rpc_trace_selected {
764 RPC_MESSAGES
765 } else {
766 SERVER_LOGS
767 },
768 )))
769 })
770 .unwrap_or_else(|| "No server selected".into()),
771 ))
772 .menu(move |cx| {
773 let menu_rows = menu_rows.clone();
774 let log_view = log_view.clone();
775 let log_toolbar_view = log_toolbar_view.clone();
776 ContextMenu::build(cx, move |mut menu, cx| {
777 for (ix, row) in menu_rows.into_iter().enumerate() {
778 let server_selected = Some(row.server_id) == current_server_id;
779 menu = menu
780 .header(format!(
781 "{} ({})",
782 row.server_name.0, row.worktree_root_name
783 ))
784 .entry(
785 SERVER_LOGS,
786 None,
787 cx.handler_for(&log_view, move |view, cx| {
788 view.show_logs_for_server(row.server_id, cx);
789 }),
790 );
791 if server_selected && row.logs_selected {
792 let selected_ix = menu.select_last();
793 debug_assert_eq!(
794 Some(ix * 3 + 1),
795 selected_ix,
796 "Could not scroll to a just added LSP menu item"
797 );
798 }
799
800 menu = menu.custom_entry(
801 {
802 let log_toolbar_view = log_toolbar_view.clone();
803 move |cx| {
804 h_flex()
805 .w_full()
806 .justify_between()
807 .child(Label::new(RPC_MESSAGES))
808 .child(
809 div().z_index(120).child(
810 Checkbox::new(
811 ix,
812 if row.rpc_trace_enabled {
813 Selection::Selected
814 } else {
815 Selection::Unselected
816 },
817 )
818 .on_click(cx.listener_for(
819 &log_toolbar_view,
820 move |view, selection, cx| {
821 let enabled = matches!(
822 selection,
823 Selection::Selected
824 );
825 view.toggle_logging_for_server(
826 row.server_id,
827 enabled,
828 cx,
829 );
830 cx.stop_propagation();
831 },
832 )),
833 ),
834 )
835 .into_any_element()
836 }
837 },
838 cx.handler_for(&log_view, move |view, cx| {
839 view.show_rpc_trace_for_server(row.server_id, cx);
840 }),
841 );
842 if server_selected && row.rpc_trace_selected {
843 let selected_ix = menu.select_last();
844 debug_assert_eq!(
845 Some(ix * 3 + 2),
846 selected_ix,
847 "Could not scroll to a just added LSP menu item"
848 );
849 }
850 }
851 menu
852 })
853 .into()
854 });
855
856 h_flex().size_full().child(lsp_menu).child(
857 div()
858 .child(
859 Button::new("clear_log_button", "Clear").on_click(cx.listener(
860 |this, _, cx| {
861 if let Some(log_view) = this.log_view.as_ref() {
862 log_view.update(cx, |log_view, cx| {
863 log_view.editor.update(cx, |editor, cx| {
864 editor.set_read_only(false);
865 editor.clear(cx);
866 editor.set_read_only(true);
867 });
868 })
869 }
870 },
871 )),
872 )
873 .ml_2(),
874 )
875 }
876}
877
878const RPC_MESSAGES: &str = "RPC Messages";
879const SERVER_LOGS: &str = "Server Logs";
880
881impl LspLogToolbarItemView {
882 pub fn new() -> Self {
883 Self {
884 log_view: None,
885 _log_view_subscription: None,
886 }
887 }
888
889 fn toggle_logging_for_server(
890 &mut self,
891 id: LanguageServerId,
892 enabled: bool,
893 cx: &mut ViewContext<Self>,
894 ) {
895 if let Some(log_view) = &self.log_view {
896 log_view.update(cx, |log_view, cx| {
897 log_view.toggle_rpc_trace_for_server(id, enabled, cx);
898 if !enabled && Some(id) == log_view.current_server_id {
899 log_view.show_logs_for_server(id, cx);
900 cx.notify();
901 }
902 cx.focus(&log_view.focus_handle);
903 });
904 }
905 cx.notify();
906 }
907}
908
909pub enum Event {
910 NewServerLogEntry {
911 id: LanguageServerId,
912 entry: String,
913 is_rpc: bool,
914 },
915}
916
917impl EventEmitter<Event> for LogStore {}
918impl EventEmitter<Event> for LspLogView {}
919impl EventEmitter<EditorEvent> for LspLogView {}
920impl EventEmitter<SearchEvent> for LspLogView {}