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