DAP log view improvements (#34311)

Now DAP logs show the label of each session which makes it much easier to pick out the right one. Also "initialization sequence" now shows up correctly when that view is selected. Release Notes: - N/A ---------

Julia Ryan committed 1 year ago

Commit c3edc2c1 parent 625a4b92 files · +56 −30Browse files

Unified · Split

2 files

crates/debugger_tools/src/dap_log.rs +55 −28
crates/debugger_ui/src/session.rs +1 −2

crates/debugger_tools/src/dap_log.rs+55−28

     ui::{Button, Clickable, ContextMenu, Label, LabelCommon, PopoverMenu, h_flex},
 };
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+enum View {
+    AdapterLogs,
+    RpcMessages,
+    InitializationSequence,
+}
 struct DapLogView {
     editor: Entity<Editor>,
     focus_handle: FocusHandle,
     log_store: Entity<LogStore>,
     editor_subscriptions: Vec<Subscription>,
-    current_view: Option<(SessionId, LogKind)>,
+    current_view: Option<(SessionId, View)>,
     project: Entity<Project>,
     _subscriptions: Vec<Subscription>,
 }
     id: SessionId,
     log_messages: VecDeque<SharedString>,
     rpc_messages: RpcMessages,
+    session_label: SharedString,
     adapter_name: DebugAdapterName,
     has_adapter_logs: bool,
     is_terminated: bool,
 }
 impl DebugAdapterState {
-    fn new(id: SessionId, adapter_name: DebugAdapterName, has_adapter_logs: bool) -> Self {
+    fn new(
+        id: SessionId,
+        adapter_name: DebugAdapterName,
+        session_label: SharedString,
+        has_adapter_logs: bool,
+    ) -> Self {
         Self {
             id,
             log_messages: VecDeque::new(),
             rpc_messages: RpcMessages::new(),
             adapter_name,
+            session_label,
             has_adapter_logs,
             is_terminated: false,
         }
                 return None;
             };
-            let (adapter_name, has_adapter_logs) = session.read_with(cx, |session, _| {
+            let (adapter_name, session_label, has_adapter_logs) =
-                (
+                session.read_with(cx, |session, _| {
-                    session.adapter(),
+                    (
-                    session
+                        session.adapter(),
-                        .adapter_client()
+                        session.label(),
-                        .map_or(false, |client| client.has_adapter_logs()),
+                        session
-                )
+                            .adapter_client()
-            });
+                            .map_or(false, |client| client.has_adapter_logs()),
+                    )
+                });
             state.insert(DebugAdapterState::new(
                 id.session_id,
                 adapter_name,
+                session_label,
                 has_adapter_logs,
             ));
                 current_client
                     .map(|sub_item| {
                         Cow::Owned(format!(
-                            "{} ({}) - {}",
+                            "{} - {} - {}",
                             sub_item.adapter_name,
-                            sub_item.session_id.0,
+                            sub_item.session_label,
                             match sub_item.selected_entry {
-                                LogKind::Adapter => ADAPTER_LOGS,
+                                View::AdapterLogs => ADAPTER_LOGS,
-                                LogKind::Rpc => RPC_MESSAGES,
+                                View::RpcMessages => RPC_MESSAGES,
+                                View::InitializationSequence => INITIALIZATION_SEQUENCE,
                             }
                         ))
                     })
                                 .pl_2()
                                 .child(
                                     Label::new(format!(
-                                        "{}. {}",
+                                        "{} - {}",
-                                        row.session_id.0, row.adapter_name,
+                                        row.adapter_name, row.session_label
                                     ))
                                     .color(workspace::ui::Color::Muted),
                                 )
         let events_subscriptions = cx.subscribe(&log_store, |log_view, _, event, cx| match event {
             Event::NewLogEntry { id, entry, kind } => {
-                if log_view.current_view == Some((id.session_id, *kind))
+                let is_current_view = match (log_view.current_view, *kind) {
-                    && log_view.project == *id.project
+                    (Some((i, View::AdapterLogs)), LogKind::Adapter)
-                {
+                    | (Some((i, View::RpcMessages)), LogKind::Rpc)
+                        if i == id.session_id =>
+                    {
+                        log_view.project == *id.project
+                    }
+                    _ => false,
+                };
+                if is_current_view {
                     log_view.editor.update(cx, |editor, cx| {
                         editor.set_read_only(false);
                         let last_point = editor.buffer().read(cx).len(cx);
                     .map(|state| DapMenuItem {
                         session_id: state.id,
                         adapter_name: state.adapter_name.clone(),
+                        session_label: state.session_label.clone(),
                         has_adapter_logs: state.has_adapter_logs,
                         selected_entry: self
                             .current_view
-                            .map_or(LogKind::Adapter, |(_, kind)| kind),
+                            .map_or(View::AdapterLogs, |(_, kind)| kind),
                     })
                     .collect::<Vec<_>>()
             })
                 .map(|state| log_contents(state.iter().cloned()))
         });
         if let Some(rpc_log) = rpc_log {
-            self.current_view = Some((id.session_id, LogKind::Rpc));
+            self.current_view = Some((id.session_id, View::RpcMessages));
             let (editor, editor_subscriptions) = Self::editor_for_logs(rpc_log, window, cx);
             let language = self.project.read(cx).languages().language_for_name("JSON");
             editor
                 .map(|state| log_contents(state.iter().cloned()))
         });
         if let Some(message_log) = message_log {
-            self.current_view = Some((id.session_id, LogKind::Adapter));
+            self.current_view = Some((id.session_id, View::AdapterLogs));
             let (editor, editor_subscriptions) = Self::editor_for_logs(message_log, window, cx);
             editor
                 .read(cx)
                 .map(|state| log_contents(state.iter().cloned()))
         });
         if let Some(rpc_log) = rpc_log {
-            self.current_view = Some((id.session_id, LogKind::Rpc));
+            self.current_view = Some((id.session_id, View::InitializationSequence));
             let (editor, editor_subscriptions) = Self::editor_for_logs(rpc_log, window, cx);
             let language = self.project.read(cx).languages().language_for_name("JSON");
             editor
 }
 #[derive(Clone, PartialEq)]
-pub(crate) struct DapMenuItem {
+struct DapMenuItem {
-    pub session_id: SessionId,
+    session_id: SessionId,
-    pub adapter_name: DebugAdapterName,
+    session_label: SharedString,
-    pub has_adapter_logs: bool,
+    adapter_name: DebugAdapterName,
-    pub selected_entry: LogKind,
+    has_adapter_logs: bool,
+    selected_entry: View,
 }
 const ADAPTER_LOGS: &str = "Adapter Logs";

crates/debugger_ui/src/session.rs+1−2

 use rpc::proto;
 use running::RunningState;
 use std::{cell::OnceCell, sync::OnceLock};
-use ui::{Indicator, Tooltip, prelude::*};
+use ui::{Indicator, prelude::*};
 use util::truncate_and_trailoff;
 use workspace::{
     CollaboratorId, FollowableItem, ViewId, Workspace,
         h_flex()
             .id("session-label")
-            .tooltip(Tooltip::text(format!("Session {}", self.session_id(cx).0,)))
             .ml(depth * px(16.0))
             .gap_2()
             .when_some(icon, |this, indicator| this.child(indicator))

DAP log view improvements (#34311)

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code