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