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