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