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