Remote LSP logs (#37083)
Take 2: https://github.com/zed-industries/zed/pull/36709 but without the very bad `cfg`-based approach for storing the RPC logs. -------------- Enables LSP log tracing in both remote collab and remote ssh environments. Server logs and server RPC traces can now be viewed remotely, and the LSP button is now shown in such projects too. Closes https://github.com/zed-industries/zed/issues/28557 Co-Authored-By: Kirill <kirill@zed.dev> Co-Authored-By: Lukas <lukas@zed.dev> Release Notes: - Enabled LSP log tracing in both remote collab and remote ssh environments --------- Co-authored-by: Ben Kunkle <ben@zed.dev> Co-authored-by: Lukas Wirth <lukas@zed.dev>
This commit is contained in:
Kirill Bulatov
co-authored by
Ben Kunkle
Lukas Wirth
Ben Kunkle
Lukas Wirth
parent
39d86eeb7f
commit
f127ba82d1
@@ -11,18 +11,22 @@
|
||||
//! Most of the interesting work happens at the local layer, as bulk of the complexity is with managing the lifecycle of language servers. The actual implementation of the LSP protocol is handled by [`lsp`] crate.
|
||||
pub mod clangd_ext;
|
||||
pub mod json_language_server_ext;
|
||||
pub mod log_store;
|
||||
pub mod lsp_ext_command;
|
||||
pub mod rust_analyzer_ext;
|
||||
|
||||
use crate::{
|
||||
CodeAction, ColorPresentation, Completion, CompletionResponse, CompletionSource,
|
||||
CoreCompletion, DocumentColor, Hover, InlayHint, LocationLink, LspAction, LspPullDiagnostics,
|
||||
ManifestProvidersStore, ProjectItem, ProjectPath, ProjectTransaction, PulledDiagnostics,
|
||||
ResolveState, Symbol,
|
||||
ManifestProvidersStore, Project, ProjectItem, ProjectPath, ProjectTransaction,
|
||||
PulledDiagnostics, ResolveState, Symbol,
|
||||
buffer_store::{BufferStore, BufferStoreEvent},
|
||||
environment::ProjectEnvironment,
|
||||
lsp_command::{self, *},
|
||||
lsp_store,
|
||||
lsp_store::{
|
||||
self,
|
||||
log_store::{GlobalLogStore, LanguageServerKind},
|
||||
},
|
||||
manifest_tree::{
|
||||
LanguageServerTree, LanguageServerTreeNode, LaunchDisposition, ManifestQueryDelegate,
|
||||
ManifestTree,
|
||||
@@ -977,7 +981,9 @@ impl LocalLspStore {
|
||||
this.update(&mut cx, |_, cx| {
|
||||
cx.emit(LspStoreEvent::LanguageServerLog(
|
||||
server_id,
|
||||
LanguageServerLogType::Trace(params.verbose),
|
||||
LanguageServerLogType::Trace {
|
||||
verbose_info: params.verbose,
|
||||
},
|
||||
params.message,
|
||||
));
|
||||
})
|
||||
@@ -3482,13 +3488,13 @@ pub struct LspStore {
|
||||
buffer_store: Entity<BufferStore>,
|
||||
worktree_store: Entity<WorktreeStore>,
|
||||
pub languages: Arc<LanguageRegistry>,
|
||||
language_server_statuses: BTreeMap<LanguageServerId, LanguageServerStatus>,
|
||||
pub language_server_statuses: BTreeMap<LanguageServerId, LanguageServerStatus>,
|
||||
active_entry: Option<ProjectEntryId>,
|
||||
_maintain_workspace_config: (Task<Result<()>>, watch::Sender<()>),
|
||||
_maintain_buffer_languages: Task<()>,
|
||||
diagnostic_summaries:
|
||||
HashMap<WorktreeId, HashMap<Arc<Path>, HashMap<LanguageServerId, DiagnosticSummary>>>,
|
||||
pub(super) lsp_server_capabilities: HashMap<LanguageServerId, lsp::ServerCapabilities>,
|
||||
pub lsp_server_capabilities: HashMap<LanguageServerId, lsp::ServerCapabilities>,
|
||||
lsp_document_colors: HashMap<BufferId, DocumentColorData>,
|
||||
lsp_code_lens: HashMap<BufferId, CodeLensData>,
|
||||
running_lsp_requests: HashMap<TypeId, (Global, HashMap<LspRequestId, Task<()>>)>,
|
||||
@@ -3565,6 +3571,7 @@ pub struct LanguageServerStatus {
|
||||
pub pending_work: BTreeMap<String, LanguageServerProgress>,
|
||||
pub has_pending_diagnostic_updates: bool,
|
||||
progress_tokens: HashSet<String>,
|
||||
pub worktree: Option<WorktreeId>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
@@ -7483,7 +7490,7 @@ impl LspStore {
|
||||
server: Some(proto::LanguageServer {
|
||||
id: server_id.to_proto(),
|
||||
name: status.name.to_string(),
|
||||
worktree_id: None,
|
||||
worktree_id: status.worktree.map(|id| id.to_proto()),
|
||||
}),
|
||||
capabilities: serde_json::to_string(&server.capabilities())
|
||||
.expect("serializing server LSP capabilities"),
|
||||
@@ -7508,9 +7515,15 @@ impl LspStore {
|
||||
|
||||
pub(crate) fn set_language_server_statuses_from_proto(
|
||||
&mut self,
|
||||
project: WeakEntity<Project>,
|
||||
language_servers: Vec<proto::LanguageServer>,
|
||||
server_capabilities: Vec<String>,
|
||||
cx: &mut Context<Self>,
|
||||
) {
|
||||
let lsp_logs = cx
|
||||
.try_global::<GlobalLogStore>()
|
||||
.map(|lsp_store| lsp_store.0.clone());
|
||||
|
||||
self.language_server_statuses = language_servers
|
||||
.into_iter()
|
||||
.zip(server_capabilities)
|
||||
@@ -7520,13 +7533,34 @@ impl LspStore {
|
||||
self.lsp_server_capabilities
|
||||
.insert(server_id, server_capabilities);
|
||||
}
|
||||
|
||||
let name = LanguageServerName::from_proto(server.name);
|
||||
let worktree = server.worktree_id.map(WorktreeId::from_proto);
|
||||
|
||||
if let Some(lsp_logs) = &lsp_logs {
|
||||
lsp_logs.update(cx, |lsp_logs, cx| {
|
||||
lsp_logs.add_language_server(
|
||||
// Only remote clients get their language servers set from proto
|
||||
LanguageServerKind::Remote {
|
||||
project: project.clone(),
|
||||
},
|
||||
server_id,
|
||||
Some(name.clone()),
|
||||
worktree,
|
||||
None,
|
||||
cx,
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
(
|
||||
server_id,
|
||||
LanguageServerStatus {
|
||||
name: LanguageServerName::from_proto(server.name),
|
||||
name,
|
||||
pending_work: Default::default(),
|
||||
has_pending_diagnostic_updates: false,
|
||||
progress_tokens: Default::default(),
|
||||
worktree,
|
||||
},
|
||||
)
|
||||
})
|
||||
@@ -8892,6 +8926,7 @@ impl LspStore {
|
||||
pending_work: Default::default(),
|
||||
has_pending_diagnostic_updates: false,
|
||||
progress_tokens: Default::default(),
|
||||
worktree: server.worktree_id.map(WorktreeId::from_proto),
|
||||
},
|
||||
);
|
||||
cx.emit(LspStoreEvent::LanguageServerAdded(
|
||||
@@ -10905,6 +10940,7 @@ impl LspStore {
|
||||
pending_work: Default::default(),
|
||||
has_pending_diagnostic_updates: false,
|
||||
progress_tokens: Default::default(),
|
||||
worktree: Some(key.worktree_id),
|
||||
},
|
||||
);
|
||||
|
||||
@@ -12190,6 +12226,14 @@ impl LspStore {
|
||||
let data = self.lsp_code_lens.get_mut(&buffer_id)?;
|
||||
Some(data.update.take()?.1)
|
||||
}
|
||||
|
||||
pub fn downstream_client(&self) -> Option<(AnyProtoClient, u64)> {
|
||||
self.downstream_client.clone()
|
||||
}
|
||||
|
||||
pub fn worktree_store(&self) -> Entity<WorktreeStore> {
|
||||
self.worktree_store.clone()
|
||||
}
|
||||
}
|
||||
|
||||
// Registration with registerOptions as null, should fallback to true.
|
||||
@@ -12699,45 +12743,69 @@ impl PartialEq for LanguageServerPromptRequest {
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub enum LanguageServerLogType {
|
||||
Log(MessageType),
|
||||
Trace(Option<String>),
|
||||
Trace { verbose_info: Option<String> },
|
||||
Rpc { received: bool },
|
||||
}
|
||||
|
||||
impl LanguageServerLogType {
|
||||
pub fn to_proto(&self) -> proto::language_server_log::LogType {
|
||||
match self {
|
||||
Self::Log(log_type) => {
|
||||
let message_type = match *log_type {
|
||||
MessageType::ERROR => 1,
|
||||
MessageType::WARNING => 2,
|
||||
MessageType::INFO => 3,
|
||||
MessageType::LOG => 4,
|
||||
use proto::log_message::LogLevel;
|
||||
let level = match *log_type {
|
||||
MessageType::ERROR => LogLevel::Error,
|
||||
MessageType::WARNING => LogLevel::Warning,
|
||||
MessageType::INFO => LogLevel::Info,
|
||||
MessageType::LOG => LogLevel::Log,
|
||||
other => {
|
||||
log::warn!("Unknown lsp log message type: {:?}", other);
|
||||
4
|
||||
log::warn!("Unknown lsp log message type: {other:?}");
|
||||
LogLevel::Log
|
||||
}
|
||||
};
|
||||
proto::language_server_log::LogType::LogMessageType(message_type)
|
||||
}
|
||||
Self::Trace(message) => {
|
||||
proto::language_server_log::LogType::LogTrace(proto::LspLogTrace {
|
||||
message: message.clone(),
|
||||
proto::language_server_log::LogType::Log(proto::LogMessage {
|
||||
level: level as i32,
|
||||
})
|
||||
}
|
||||
Self::Trace { verbose_info } => {
|
||||
proto::language_server_log::LogType::Trace(proto::TraceMessage {
|
||||
verbose_info: verbose_info.to_owned(),
|
||||
})
|
||||
}
|
||||
Self::Rpc { received } => {
|
||||
let kind = if *received {
|
||||
proto::rpc_message::Kind::Received
|
||||
} else {
|
||||
proto::rpc_message::Kind::Sent
|
||||
};
|
||||
let kind = kind as i32;
|
||||
proto::language_server_log::LogType::Rpc(proto::RpcMessage { kind })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn from_proto(log_type: proto::language_server_log::LogType) -> Self {
|
||||
use proto::log_message::LogLevel;
|
||||
use proto::rpc_message;
|
||||
match log_type {
|
||||
proto::language_server_log::LogType::LogMessageType(message_type) => {
|
||||
Self::Log(match message_type {
|
||||
1 => MessageType::ERROR,
|
||||
2 => MessageType::WARNING,
|
||||
3 => MessageType::INFO,
|
||||
4 => MessageType::LOG,
|
||||
_ => MessageType::LOG,
|
||||
})
|
||||
}
|
||||
proto::language_server_log::LogType::LogTrace(trace) => Self::Trace(trace.message),
|
||||
proto::language_server_log::LogType::Log(message_type) => Self::Log(
|
||||
match LogLevel::from_i32(message_type.level).unwrap_or(LogLevel::Log) {
|
||||
LogLevel::Error => MessageType::ERROR,
|
||||
LogLevel::Warning => MessageType::WARNING,
|
||||
LogLevel::Info => MessageType::INFO,
|
||||
LogLevel::Log => MessageType::LOG,
|
||||
},
|
||||
),
|
||||
proto::language_server_log::LogType::Trace(trace_message) => Self::Trace {
|
||||
verbose_info: trace_message.verbose_info,
|
||||
},
|
||||
proto::language_server_log::LogType::Rpc(message) => Self::Rpc {
|
||||
received: match rpc_message::Kind::from_i32(message.kind)
|
||||
.unwrap_or(rpc_message::Kind::Received)
|
||||
{
|
||||
rpc_message::Kind::Received => true,
|
||||
rpc_message::Kind::Sent => false,
|
||||
},
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,704 @@
|
||||
use std::{collections::VecDeque, sync::Arc};
|
||||
|
||||
use collections::HashMap;
|
||||
use futures::{StreamExt, channel::mpsc};
|
||||
use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Global, Subscription, WeakEntity};
|
||||
use lsp::{
|
||||
IoKind, LanguageServer, LanguageServerId, LanguageServerName, LanguageServerSelector,
|
||||
MessageType, TraceValue,
|
||||
};
|
||||
use rpc::proto;
|
||||
use settings::WorktreeId;
|
||||
|
||||
use crate::{LanguageServerLogType, LspStore, Project, ProjectItem as _};
|
||||
|
||||
const SEND_LINE: &str = "\n// Send:";
|
||||
const RECEIVE_LINE: &str = "\n// Receive:";
|
||||
const MAX_STORED_LOG_ENTRIES: usize = 2000;
|
||||
|
||||
const RPC_MESSAGES: &str = "RPC Messages";
|
||||
const SERVER_LOGS: &str = "Server Logs";
|
||||
const SERVER_TRACE: &str = "Server Trace";
|
||||
const SERVER_INFO: &str = "Server Info";
|
||||
|
||||
pub fn init(store_logs: bool, cx: &mut App) -> Entity<LogStore> {
|
||||
let log_store = cx.new(|cx| LogStore::new(store_logs, cx));
|
||||
cx.set_global(GlobalLogStore(log_store.clone()));
|
||||
log_store
|
||||
}
|
||||
|
||||
pub struct GlobalLogStore(pub Entity<LogStore>);
|
||||
|
||||
impl Global for GlobalLogStore {}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub enum Event {
|
||||
NewServerLogEntry {
|
||||
id: LanguageServerId,
|
||||
kind: LanguageServerLogType,
|
||||
text: String,
|
||||
},
|
||||
}
|
||||
|
||||
impl EventEmitter<Event> for LogStore {}
|
||||
|
||||
pub struct LogStore {
|
||||
store_logs: bool,
|
||||
projects: HashMap<WeakEntity<Project>, ProjectState>,
|
||||
pub copilot_log_subscription: Option<lsp::Subscription>,
|
||||
pub language_servers: HashMap<LanguageServerId, LanguageServerState>,
|
||||
io_tx: mpsc::UnboundedSender<(LanguageServerId, IoKind, String)>,
|
||||
}
|
||||
|
||||
struct ProjectState {
|
||||
_subscriptions: [Subscription; 2],
|
||||
}
|
||||
|
||||
pub trait Message: AsRef<str> {
|
||||
type Level: Copy + std::fmt::Debug;
|
||||
fn should_include(&self, _: Self::Level) -> bool {
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct LogMessage {
|
||||
message: String,
|
||||
typ: MessageType,
|
||||
}
|
||||
|
||||
impl AsRef<str> for LogMessage {
|
||||
fn as_ref(&self) -> &str {
|
||||
&self.message
|
||||
}
|
||||
}
|
||||
|
||||
impl Message for LogMessage {
|
||||
type Level = MessageType;
|
||||
|
||||
fn should_include(&self, level: Self::Level) -> bool {
|
||||
match (self.typ, level) {
|
||||
(MessageType::ERROR, _) => true,
|
||||
(_, MessageType::ERROR) => false,
|
||||
(MessageType::WARNING, _) => true,
|
||||
(_, MessageType::WARNING) => false,
|
||||
(MessageType::INFO, _) => true,
|
||||
(_, MessageType::INFO) => false,
|
||||
_ => true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct TraceMessage {
|
||||
message: String,
|
||||
is_verbose: bool,
|
||||
}
|
||||
|
||||
impl AsRef<str> for TraceMessage {
|
||||
fn as_ref(&self) -> &str {
|
||||
&self.message
|
||||
}
|
||||
}
|
||||
|
||||
impl Message for TraceMessage {
|
||||
type Level = TraceValue;
|
||||
|
||||
fn should_include(&self, level: Self::Level) -> bool {
|
||||
match level {
|
||||
TraceValue::Off => false,
|
||||
TraceValue::Messages => !self.is_verbose,
|
||||
TraceValue::Verbose => true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct RpcMessage {
|
||||
message: String,
|
||||
}
|
||||
|
||||
impl AsRef<str> for RpcMessage {
|
||||
fn as_ref(&self) -> &str {
|
||||
&self.message
|
||||
}
|
||||
}
|
||||
|
||||
impl Message for RpcMessage {
|
||||
type Level = ();
|
||||
}
|
||||
|
||||
pub struct LanguageServerState {
|
||||
pub name: Option<LanguageServerName>,
|
||||
pub worktree_id: Option<WorktreeId>,
|
||||
pub kind: LanguageServerKind,
|
||||
log_messages: VecDeque<LogMessage>,
|
||||
trace_messages: VecDeque<TraceMessage>,
|
||||
pub rpc_state: Option<LanguageServerRpcState>,
|
||||
pub trace_level: TraceValue,
|
||||
pub log_level: MessageType,
|
||||
io_logs_subscription: Option<lsp::Subscription>,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for LanguageServerState {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
f.debug_struct("LanguageServerState")
|
||||
.field("name", &self.name)
|
||||
.field("worktree_id", &self.worktree_id)
|
||||
.field("kind", &self.kind)
|
||||
.field("log_messages", &self.log_messages)
|
||||
.field("trace_messages", &self.trace_messages)
|
||||
.field("rpc_state", &self.rpc_state)
|
||||
.field("trace_level", &self.trace_level)
|
||||
.field("log_level", &self.log_level)
|
||||
.finish_non_exhaustive()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(PartialEq, Clone)]
|
||||
pub enum LanguageServerKind {
|
||||
Local { project: WeakEntity<Project> },
|
||||
Remote { project: WeakEntity<Project> },
|
||||
LocalSsh { lsp_store: WeakEntity<LspStore> },
|
||||
Global,
|
||||
}
|
||||
|
||||
impl std::fmt::Debug for LanguageServerKind {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
LanguageServerKind::Local { .. } => write!(f, "LanguageServerKind::Local"),
|
||||
LanguageServerKind::Remote { .. } => write!(f, "LanguageServerKind::Remote"),
|
||||
LanguageServerKind::LocalSsh { .. } => write!(f, "LanguageServerKind::LocalSsh"),
|
||||
LanguageServerKind::Global => write!(f, "LanguageServerKind::Global"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl LanguageServerKind {
|
||||
pub fn project(&self) -> Option<&WeakEntity<Project>> {
|
||||
match self {
|
||||
Self::Local { project } => Some(project),
|
||||
Self::Remote { project } => Some(project),
|
||||
Self::LocalSsh { .. } => None,
|
||||
Self::Global { .. } => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct LanguageServerRpcState {
|
||||
pub rpc_messages: VecDeque<RpcMessage>,
|
||||
last_message_kind: Option<MessageKind>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Copy, Clone, PartialEq, Eq)]
|
||||
enum MessageKind {
|
||||
Send,
|
||||
Receive,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq)]
|
||||
pub enum LogKind {
|
||||
Rpc,
|
||||
Trace,
|
||||
#[default]
|
||||
Logs,
|
||||
ServerInfo,
|
||||
}
|
||||
|
||||
impl LogKind {
|
||||
pub fn from_server_log_type(log_type: &LanguageServerLogType) -> Self {
|
||||
match log_type {
|
||||
LanguageServerLogType::Log(_) => Self::Logs,
|
||||
LanguageServerLogType::Trace { .. } => Self::Trace,
|
||||
LanguageServerLogType::Rpc { .. } => Self::Rpc,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn label(&self) -> &'static str {
|
||||
match self {
|
||||
LogKind::Rpc => RPC_MESSAGES,
|
||||
LogKind::Trace => SERVER_TRACE,
|
||||
LogKind::Logs => SERVER_LOGS,
|
||||
LogKind::ServerInfo => SERVER_INFO,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl LogStore {
|
||||
pub fn new(store_logs: bool, cx: &mut Context<Self>) -> Self {
|
||||
let (io_tx, mut io_rx) = mpsc::unbounded();
|
||||
|
||||
let log_store = Self {
|
||||
projects: HashMap::default(),
|
||||
language_servers: HashMap::default(),
|
||||
copilot_log_subscription: None,
|
||||
store_logs,
|
||||
io_tx,
|
||||
};
|
||||
cx.spawn(async move |log_store, cx| {
|
||||
while let Some((server_id, io_kind, message)) = io_rx.next().await {
|
||||
if let Some(log_store) = log_store.upgrade() {
|
||||
log_store.update(cx, |log_store, cx| {
|
||||
log_store.on_io(server_id, io_kind, &message, cx);
|
||||
})?;
|
||||
}
|
||||
}
|
||||
anyhow::Ok(())
|
||||
})
|
||||
.detach_and_log_err(cx);
|
||||
|
||||
log_store
|
||||
}
|
||||
|
||||
pub fn add_project(&mut self, project: &Entity<Project>, cx: &mut Context<Self>) {
|
||||
let weak_project = project.downgrade();
|
||||
self.projects.insert(
|
||||
project.downgrade(),
|
||||
ProjectState {
|
||||
_subscriptions: [
|
||||
cx.observe_release(project, move |this, _, _| {
|
||||
this.projects.remove(&weak_project);
|
||||
this.language_servers
|
||||
.retain(|_, state| state.kind.project() != Some(&weak_project));
|
||||
}),
|
||||
cx.subscribe(project, move |log_store, project, event, cx| {
|
||||
let server_kind = if project.read(cx).is_local() {
|
||||
LanguageServerKind::Local {
|
||||
project: project.downgrade(),
|
||||
}
|
||||
} else {
|
||||
LanguageServerKind::Remote {
|
||||
project: project.downgrade(),
|
||||
}
|
||||
};
|
||||
match event {
|
||||
crate::Event::LanguageServerAdded(id, name, worktree_id) => {
|
||||
log_store.add_language_server(
|
||||
server_kind,
|
||||
*id,
|
||||
Some(name.clone()),
|
||||
*worktree_id,
|
||||
project
|
||||
.read(cx)
|
||||
.lsp_store()
|
||||
.read(cx)
|
||||
.language_server_for_id(*id),
|
||||
cx,
|
||||
);
|
||||
}
|
||||
crate::Event::LanguageServerBufferRegistered {
|
||||
server_id,
|
||||
buffer_id,
|
||||
name,
|
||||
..
|
||||
} => {
|
||||
let worktree_id = project
|
||||
.read(cx)
|
||||
.buffer_for_id(*buffer_id, cx)
|
||||
.and_then(|buffer| {
|
||||
Some(buffer.read(cx).project_path(cx)?.worktree_id)
|
||||
});
|
||||
let name = name.clone().or_else(|| {
|
||||
project
|
||||
.read(cx)
|
||||
.lsp_store()
|
||||
.read(cx)
|
||||
.language_server_statuses
|
||||
.get(server_id)
|
||||
.map(|status| status.name.clone())
|
||||
});
|
||||
log_store.add_language_server(
|
||||
server_kind,
|
||||
*server_id,
|
||||
name,
|
||||
worktree_id,
|
||||
None,
|
||||
cx,
|
||||
);
|
||||
}
|
||||
crate::Event::LanguageServerRemoved(id) => {
|
||||
log_store.remove_language_server(*id, cx);
|
||||
}
|
||||
crate::Event::LanguageServerLog(id, typ, message) => {
|
||||
log_store.add_language_server(
|
||||
server_kind,
|
||||
*id,
|
||||
None,
|
||||
None,
|
||||
None,
|
||||
cx,
|
||||
);
|
||||
match typ {
|
||||
crate::LanguageServerLogType::Log(typ) => {
|
||||
log_store.add_language_server_log(*id, *typ, message, cx);
|
||||
}
|
||||
crate::LanguageServerLogType::Trace { verbose_info } => {
|
||||
log_store.add_language_server_trace(
|
||||
*id,
|
||||
message,
|
||||
verbose_info.clone(),
|
||||
cx,
|
||||
);
|
||||
}
|
||||
crate::LanguageServerLogType::Rpc { received } => {
|
||||
let kind = if *received {
|
||||
MessageKind::Receive
|
||||
} else {
|
||||
MessageKind::Send
|
||||
};
|
||||
log_store.add_language_server_rpc(*id, kind, message, cx);
|
||||
}
|
||||
}
|
||||
}
|
||||
crate::Event::ToggleLspLogs { server_id, enabled } => {
|
||||
// we do not support any other log toggling yet
|
||||
if *enabled {
|
||||
log_store.enable_rpc_trace_for_language_server(*server_id);
|
||||
} else {
|
||||
log_store.disable_rpc_trace_for_language_server(*server_id);
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}),
|
||||
],
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
pub fn get_language_server_state(
|
||||
&mut self,
|
||||
id: LanguageServerId,
|
||||
) -> Option<&mut LanguageServerState> {
|
||||
self.language_servers.get_mut(&id)
|
||||
}
|
||||
|
||||
pub fn add_language_server(
|
||||
&mut self,
|
||||
kind: LanguageServerKind,
|
||||
server_id: LanguageServerId,
|
||||
name: Option<LanguageServerName>,
|
||||
worktree_id: Option<WorktreeId>,
|
||||
server: Option<Arc<LanguageServer>>,
|
||||
cx: &mut Context<Self>,
|
||||
) -> Option<&mut LanguageServerState> {
|
||||
let server_state = self.language_servers.entry(server_id).or_insert_with(|| {
|
||||
cx.notify();
|
||||
LanguageServerState {
|
||||
name: None,
|
||||
worktree_id: None,
|
||||
kind,
|
||||
rpc_state: None,
|
||||
log_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
|
||||
trace_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
|
||||
trace_level: TraceValue::Off,
|
||||
log_level: MessageType::LOG,
|
||||
io_logs_subscription: None,
|
||||
}
|
||||
});
|
||||
|
||||
if let Some(name) = name {
|
||||
server_state.name = Some(name);
|
||||
}
|
||||
if let Some(worktree_id) = worktree_id {
|
||||
server_state.worktree_id = Some(worktree_id);
|
||||
}
|
||||
|
||||
if let Some(server) = server.filter(|_| server_state.io_logs_subscription.is_none()) {
|
||||
let io_tx = self.io_tx.clone();
|
||||
let server_id = server.server_id();
|
||||
server_state.io_logs_subscription = Some(server.on_io(move |io_kind, message| {
|
||||
io_tx
|
||||
.unbounded_send((server_id, io_kind, message.to_string()))
|
||||
.ok();
|
||||
}));
|
||||
}
|
||||
|
||||
Some(server_state)
|
||||
}
|
||||
|
||||
pub fn add_language_server_log(
|
||||
&mut self,
|
||||
id: LanguageServerId,
|
||||
typ: MessageType,
|
||||
message: &str,
|
||||
cx: &mut Context<Self>,
|
||||
) -> Option<()> {
|
||||
let store_logs = self.store_logs;
|
||||
let language_server_state = self.get_language_server_state(id)?;
|
||||
|
||||
let log_lines = &mut language_server_state.log_messages;
|
||||
let message = message.trim_end().to_string();
|
||||
if !store_logs {
|
||||
// Send all messages regardless of the visibility in case of not storing, to notify the receiver anyway
|
||||
self.emit_event(
|
||||
Event::NewServerLogEntry {
|
||||
id,
|
||||
kind: LanguageServerLogType::Log(typ),
|
||||
text: message,
|
||||
},
|
||||
cx,
|
||||
);
|
||||
} else if let Some(new_message) = Self::push_new_message(
|
||||
log_lines,
|
||||
LogMessage { message, typ },
|
||||
language_server_state.log_level,
|
||||
) {
|
||||
self.emit_event(
|
||||
Event::NewServerLogEntry {
|
||||
id,
|
||||
kind: LanguageServerLogType::Log(typ),
|
||||
text: new_message,
|
||||
},
|
||||
cx,
|
||||
);
|
||||
}
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn add_language_server_trace(
|
||||
&mut self,
|
||||
id: LanguageServerId,
|
||||
message: &str,
|
||||
verbose_info: Option<String>,
|
||||
cx: &mut Context<Self>,
|
||||
) -> Option<()> {
|
||||
let store_logs = self.store_logs;
|
||||
let language_server_state = self.get_language_server_state(id)?;
|
||||
|
||||
let log_lines = &mut language_server_state.trace_messages;
|
||||
if !store_logs {
|
||||
// Send all messages regardless of the visibility in case of not storing, to notify the receiver anyway
|
||||
self.emit_event(
|
||||
Event::NewServerLogEntry {
|
||||
id,
|
||||
kind: LanguageServerLogType::Trace { verbose_info },
|
||||
text: message.trim().to_string(),
|
||||
},
|
||||
cx,
|
||||
);
|
||||
} else if let Some(new_message) = Self::push_new_message(
|
||||
log_lines,
|
||||
TraceMessage {
|
||||
message: message.trim().to_string(),
|
||||
is_verbose: false,
|
||||
},
|
||||
TraceValue::Messages,
|
||||
) {
|
||||
if let Some(verbose_message) = verbose_info.as_ref() {
|
||||
Self::push_new_message(
|
||||
log_lines,
|
||||
TraceMessage {
|
||||
message: verbose_message.clone(),
|
||||
is_verbose: true,
|
||||
},
|
||||
TraceValue::Verbose,
|
||||
);
|
||||
}
|
||||
self.emit_event(
|
||||
Event::NewServerLogEntry {
|
||||
id,
|
||||
kind: LanguageServerLogType::Trace { verbose_info },
|
||||
text: new_message,
|
||||
},
|
||||
cx,
|
||||
);
|
||||
}
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn push_new_message<T: Message>(
|
||||
log_lines: &mut VecDeque<T>,
|
||||
message: T,
|
||||
current_severity: <T as Message>::Level,
|
||||
) -> Option<String> {
|
||||
while log_lines.len() + 1 >= MAX_STORED_LOG_ENTRIES {
|
||||
log_lines.pop_front();
|
||||
}
|
||||
let visible = message.should_include(current_severity);
|
||||
|
||||
let visible_message = visible.then(|| message.as_ref().to_string());
|
||||
log_lines.push_back(message);
|
||||
visible_message
|
||||
}
|
||||
|
||||
fn add_language_server_rpc(
|
||||
&mut self,
|
||||
language_server_id: LanguageServerId,
|
||||
kind: MessageKind,
|
||||
message: &str,
|
||||
cx: &mut Context<'_, Self>,
|
||||
) {
|
||||
let store_logs = self.store_logs;
|
||||
let Some(state) = self
|
||||
.get_language_server_state(language_server_id)
|
||||
.and_then(|state| state.rpc_state.as_mut())
|
||||
else {
|
||||
return;
|
||||
};
|
||||
|
||||
let received = kind == MessageKind::Receive;
|
||||
let rpc_log_lines = &mut state.rpc_messages;
|
||||
if state.last_message_kind != Some(kind) {
|
||||
while rpc_log_lines.len() + 1 >= MAX_STORED_LOG_ENTRIES {
|
||||
rpc_log_lines.pop_front();
|
||||
}
|
||||
let line_before_message = match kind {
|
||||
MessageKind::Send => SEND_LINE,
|
||||
MessageKind::Receive => RECEIVE_LINE,
|
||||
};
|
||||
if store_logs {
|
||||
rpc_log_lines.push_back(RpcMessage {
|
||||
message: line_before_message.to_string(),
|
||||
});
|
||||
}
|
||||
// Do not send a synthetic message over the wire, it will be derived from the actual RPC message
|
||||
cx.emit(Event::NewServerLogEntry {
|
||||
id: language_server_id,
|
||||
kind: LanguageServerLogType::Rpc { received },
|
||||
text: line_before_message.to_string(),
|
||||
});
|
||||
}
|
||||
|
||||
while rpc_log_lines.len() + 1 >= MAX_STORED_LOG_ENTRIES {
|
||||
rpc_log_lines.pop_front();
|
||||
}
|
||||
|
||||
if store_logs {
|
||||
rpc_log_lines.push_back(RpcMessage {
|
||||
message: message.trim().to_owned(),
|
||||
});
|
||||
}
|
||||
|
||||
self.emit_event(
|
||||
Event::NewServerLogEntry {
|
||||
id: language_server_id,
|
||||
kind: LanguageServerLogType::Rpc { received },
|
||||
text: message.to_owned(),
|
||||
},
|
||||
cx,
|
||||
);
|
||||
}
|
||||
|
||||
pub fn remove_language_server(&mut self, id: LanguageServerId, cx: &mut Context<Self>) {
|
||||
self.language_servers.remove(&id);
|
||||
cx.notify();
|
||||
}
|
||||
|
||||
pub fn server_logs(&self, server_id: LanguageServerId) -> Option<&VecDeque<LogMessage>> {
|
||||
Some(&self.language_servers.get(&server_id)?.log_messages)
|
||||
}
|
||||
|
||||
pub fn server_trace(&self, server_id: LanguageServerId) -> Option<&VecDeque<TraceMessage>> {
|
||||
Some(&self.language_servers.get(&server_id)?.trace_messages)
|
||||
}
|
||||
|
||||
pub fn server_ids_for_project<'a>(
|
||||
&'a self,
|
||||
lookup_project: &'a WeakEntity<Project>,
|
||||
) -> impl Iterator<Item = LanguageServerId> + 'a {
|
||||
self.language_servers
|
||||
.iter()
|
||||
.filter_map(move |(id, state)| match &state.kind {
|
||||
LanguageServerKind::Local { project } | LanguageServerKind::Remote { project } => {
|
||||
if project == lookup_project {
|
||||
Some(*id)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
LanguageServerKind::Global | LanguageServerKind::LocalSsh { .. } => Some(*id),
|
||||
})
|
||||
}
|
||||
|
||||
pub fn enable_rpc_trace_for_language_server(
|
||||
&mut self,
|
||||
server_id: LanguageServerId,
|
||||
) -> Option<&mut LanguageServerRpcState> {
|
||||
let rpc_state = self
|
||||
.language_servers
|
||||
.get_mut(&server_id)?
|
||||
.rpc_state
|
||||
.get_or_insert_with(|| LanguageServerRpcState {
|
||||
rpc_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
|
||||
last_message_kind: None,
|
||||
});
|
||||
Some(rpc_state)
|
||||
}
|
||||
|
||||
pub fn disable_rpc_trace_for_language_server(
|
||||
&mut self,
|
||||
server_id: LanguageServerId,
|
||||
) -> Option<()> {
|
||||
self.language_servers.get_mut(&server_id)?.rpc_state.take();
|
||||
Some(())
|
||||
}
|
||||
|
||||
pub fn has_server_logs(&self, server: &LanguageServerSelector) -> bool {
|
||||
match server {
|
||||
LanguageServerSelector::Id(id) => self.language_servers.contains_key(id),
|
||||
LanguageServerSelector::Name(name) => self
|
||||
.language_servers
|
||||
.iter()
|
||||
.any(|(_, state)| state.name.as_ref() == Some(name)),
|
||||
}
|
||||
}
|
||||
|
||||
fn on_io(
|
||||
&mut self,
|
||||
language_server_id: LanguageServerId,
|
||||
io_kind: IoKind,
|
||||
message: &str,
|
||||
cx: &mut Context<Self>,
|
||||
) -> Option<()> {
|
||||
let is_received = match io_kind {
|
||||
IoKind::StdOut => true,
|
||||
IoKind::StdIn => false,
|
||||
IoKind::StdErr => {
|
||||
self.add_language_server_log(language_server_id, MessageType::LOG, message, cx);
|
||||
return Some(());
|
||||
}
|
||||
};
|
||||
|
||||
let kind = if is_received {
|
||||
MessageKind::Receive
|
||||
} else {
|
||||
MessageKind::Send
|
||||
};
|
||||
|
||||
self.add_language_server_rpc(language_server_id, kind, message, cx);
|
||||
cx.notify();
|
||||
Some(())
|
||||
}
|
||||
|
||||
fn emit_event(&mut self, e: Event, cx: &mut Context<Self>) {
|
||||
match &e {
|
||||
Event::NewServerLogEntry { id, kind, text } => {
|
||||
if let Some(state) = self.get_language_server_state(*id) {
|
||||
let downstream_client = match &state.kind {
|
||||
LanguageServerKind::Remote { project }
|
||||
| LanguageServerKind::Local { project } => project
|
||||
.upgrade()
|
||||
.map(|project| project.read(cx).lsp_store()),
|
||||
LanguageServerKind::LocalSsh { lsp_store } => lsp_store.upgrade(),
|
||||
LanguageServerKind::Global => None,
|
||||
}
|
||||
.and_then(|lsp_store| lsp_store.read(cx).downstream_client());
|
||||
if let Some((client, project_id)) = downstream_client {
|
||||
client
|
||||
.send(proto::LanguageServerLog {
|
||||
project_id,
|
||||
language_server_id: id.to_proto(),
|
||||
message: text.clone(),
|
||||
log_type: Some(kind.to_proto()),
|
||||
})
|
||||
.ok();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
cx.emit(e);
|
||||
}
|
||||
}
|
||||
@@ -280,6 +280,11 @@ pub enum Event {
|
||||
server_id: LanguageServerId,
|
||||
buffer_id: BufferId,
|
||||
buffer_abs_path: PathBuf,
|
||||
name: Option<LanguageServerName>,
|
||||
},
|
||||
ToggleLspLogs {
|
||||
server_id: LanguageServerId,
|
||||
enabled: bool,
|
||||
},
|
||||
Toast {
|
||||
notification_id: SharedString,
|
||||
@@ -1001,6 +1006,7 @@ impl Project {
|
||||
client.add_entity_request_handler(Self::handle_open_buffer_by_path);
|
||||
client.add_entity_request_handler(Self::handle_open_new_buffer);
|
||||
client.add_entity_message_handler(Self::handle_create_buffer_for_peer);
|
||||
client.add_entity_message_handler(Self::handle_toggle_lsp_logs);
|
||||
|
||||
WorktreeStore::init(&client);
|
||||
BufferStore::init(&client);
|
||||
@@ -1475,7 +1481,7 @@ impl Project {
|
||||
})?;
|
||||
|
||||
let lsp_store = cx.new(|cx| {
|
||||
let mut lsp_store = LspStore::new_remote(
|
||||
LspStore::new_remote(
|
||||
buffer_store.clone(),
|
||||
worktree_store.clone(),
|
||||
languages.clone(),
|
||||
@@ -1483,12 +1489,7 @@ impl Project {
|
||||
remote_id,
|
||||
fs.clone(),
|
||||
cx,
|
||||
);
|
||||
lsp_store.set_language_server_statuses_from_proto(
|
||||
response.payload.language_servers,
|
||||
response.payload.language_server_capabilities,
|
||||
);
|
||||
lsp_store
|
||||
)
|
||||
})?;
|
||||
|
||||
let task_store = cx.new(|cx| {
|
||||
@@ -1522,7 +1523,7 @@ impl Project {
|
||||
)
|
||||
})?;
|
||||
|
||||
let this = cx.new(|cx| {
|
||||
let project = cx.new(|cx| {
|
||||
let replica_id = response.payload.replica_id as ReplicaId;
|
||||
|
||||
let snippets = SnippetProvider::new(fs.clone(), BTreeSet::from_iter([]), cx);
|
||||
@@ -1553,7 +1554,7 @@ impl Project {
|
||||
|
||||
cx.subscribe(&dap_store, Self::on_dap_store_event).detach();
|
||||
|
||||
let mut this = Self {
|
||||
let mut project = Self {
|
||||
buffer_ordered_messages_tx: tx,
|
||||
buffer_store: buffer_store.clone(),
|
||||
image_store,
|
||||
@@ -1596,13 +1597,25 @@ impl Project {
|
||||
toolchain_store: None,
|
||||
agent_location: None,
|
||||
};
|
||||
this.set_role(role, cx);
|
||||
project.set_role(role, cx);
|
||||
for worktree in worktrees {
|
||||
this.add_worktree(&worktree, cx);
|
||||
project.add_worktree(&worktree, cx);
|
||||
}
|
||||
this
|
||||
project
|
||||
})?;
|
||||
|
||||
let weak_project = project.downgrade();
|
||||
lsp_store
|
||||
.update(&mut cx, |lsp_store, cx| {
|
||||
lsp_store.set_language_server_statuses_from_proto(
|
||||
weak_project,
|
||||
response.payload.language_servers,
|
||||
response.payload.language_server_capabilities,
|
||||
cx,
|
||||
);
|
||||
})
|
||||
.ok();
|
||||
|
||||
let subscriptions = subscriptions
|
||||
.into_iter()
|
||||
.map(|s| match s {
|
||||
@@ -1618,7 +1631,7 @@ impl Project {
|
||||
EntitySubscription::SettingsObserver(subscription) => {
|
||||
subscription.set_entity(&settings_observer, &cx)
|
||||
}
|
||||
EntitySubscription::Project(subscription) => subscription.set_entity(&this, &cx),
|
||||
EntitySubscription::Project(subscription) => subscription.set_entity(&project, &cx),
|
||||
EntitySubscription::LspStore(subscription) => {
|
||||
subscription.set_entity(&lsp_store, &cx)
|
||||
}
|
||||
@@ -1638,13 +1651,13 @@ impl Project {
|
||||
.update(&mut cx, |user_store, cx| user_store.get_users(user_ids, cx))?
|
||||
.await?;
|
||||
|
||||
this.update(&mut cx, |this, cx| {
|
||||
project.update(&mut cx, |this, cx| {
|
||||
this.set_collaborators_from_proto(response.payload.collaborators, cx)?;
|
||||
this.client_subscriptions.extend(subscriptions);
|
||||
anyhow::Ok(())
|
||||
})??;
|
||||
|
||||
Ok(this)
|
||||
Ok(project)
|
||||
}
|
||||
|
||||
fn new_search_history() -> SearchHistory {
|
||||
@@ -2315,10 +2328,14 @@ impl Project {
|
||||
self.join_project_response_message_id = message_id;
|
||||
self.set_worktrees_from_proto(message.worktrees, cx)?;
|
||||
self.set_collaborators_from_proto(message.collaborators, cx)?;
|
||||
self.lsp_store.update(cx, |lsp_store, _| {
|
||||
|
||||
let project = cx.weak_entity();
|
||||
self.lsp_store.update(cx, |lsp_store, cx| {
|
||||
lsp_store.set_language_server_statuses_from_proto(
|
||||
project,
|
||||
message.language_servers,
|
||||
message.language_server_capabilities,
|
||||
cx,
|
||||
)
|
||||
});
|
||||
self.enqueue_buffer_ordered_message(BufferOrderedMessage::Resync)
|
||||
@@ -2971,6 +2988,7 @@ impl Project {
|
||||
buffer_id,
|
||||
server_id: *language_server_id,
|
||||
buffer_abs_path: PathBuf::from(&update.buffer_abs_path),
|
||||
name: name.clone(),
|
||||
});
|
||||
}
|
||||
}
|
||||
@@ -4697,6 +4715,20 @@ impl Project {
|
||||
})?
|
||||
}
|
||||
|
||||
async fn handle_toggle_lsp_logs(
|
||||
project: Entity<Self>,
|
||||
envelope: TypedEnvelope<proto::ToggleLspLogs>,
|
||||
mut cx: AsyncApp,
|
||||
) -> Result<()> {
|
||||
project.update(&mut cx, |_, cx| {
|
||||
cx.emit(Event::ToggleLspLogs {
|
||||
server_id: LanguageServerId::from_proto(envelope.payload.server_id),
|
||||
enabled: envelope.payload.enabled,
|
||||
})
|
||||
})?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn handle_synchronize_buffers(
|
||||
this: Entity<Self>,
|
||||
envelope: TypedEnvelope<proto::SynchronizeBuffers>,
|
||||
|
||||
@@ -1951,6 +1951,7 @@ async fn test_restarting_server_with_diagnostics_running(cx: &mut gpui::TestAppC
|
||||
server_id: LanguageServerId(1),
|
||||
buffer_id,
|
||||
buffer_abs_path: PathBuf::from(path!("/dir/a.rs")),
|
||||
name: Some(fake_server.server.name())
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
|
||||
Reference in New Issue
Block a user