language server: use tracing and tracing-subscriber

.cargo/config.toml

@@ -0,0 +1,3 @@
+[build]
+rustflags = ["--cfg", "tokio_unstable"]
+

crates/language-server/Cargo.toml

@@ -49,3 +49,6 @@ console-subscriber = "0.2.0"
 vfs = "0.12.0"
 rust-embed = "8.3.0"
 futures-batch = "0.6.1"
+tracing = "0.1.40"
+tracing-subscriber = "0.3.18"
+tracing-appender = "0.2.3"

crates/language-server/src/backend.rs

@@ -24,7 +24,7 @@ use crate::globals::LANGUAGE_ID;
 use crate::language_server::MessageReceivers;
 use crate::workspace::{IngotFileContext, SyncableInputFile, Workspace};
 
-use log::info;
+use tracing::info;
 
 // use tokio_stream::StreamExt;
 

crates/language-server/src/handlers/request.rs

@@ -6,7 +6,7 @@ use hir_analysis::{
     name_resolution::{EarlyResolvedPath, NameRes},
     HirAnalysisDb,
 };
-use log::info;
+use tracing::info;
 
 use salsa::Snapshot;
 use tokio::sync::RwLock;

crates/language-server/src/language_server.rs

@@ -1,9 +1,9 @@
-use log::{error, info};
 use lsp_types::{
     DidChangeWatchedFilesParams, DidChangeWatchedFilesRegistrationOptions,
     DidCloseTextDocumentParams, FileSystemWatcher, GlobPattern, InitializeParams, InitializeResult,
     Registration,
 };
+use tracing::{error, info};
 
 use tower_lsp::{jsonrpc::Result, Client, LanguageServer};
 

crates/language-server/src/logger.rs

@@ -1,55 +1,69 @@
-use log::{Level, LevelFilter, Metadata, Record, SetLoggerError};
+use std::io::Write;
+
 use lsp_types::MessageType;
 use tokio::task::yield_now;
 use tower_lsp::Client;
+use tracing_subscriber::fmt::writer::MakeWriterExt;
+use tracing_subscriber::fmt::MakeWriter;
+use tracing_subscriber::layer::SubscriberExt;
+use tracing_subscriber::prelude::*;
 
-pub struct Logger {
-    pub(crate) level: Level,
+pub async fn handle_log_messages(
+    mut rx: tokio::sync::mpsc::UnboundedReceiver<(String, MessageType)>,
+    client: Client,
+) -> tokio::sync::mpsc::UnboundedReceiver<String> {
+    loop {
+        if let Some((message, message_type)) = rx.recv().await {
+            client.log_message(message_type, message).await;
+            yield_now().await;
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct LoggerLayer {
     log_sender: tokio::sync::mpsc::UnboundedSender<(String, MessageType)>,
 }
 
-impl log::Log for Logger {
-    fn enabled(&self, metadata: &Metadata) -> bool {
-        let logger = self;
-        metadata.level() <= logger.level
+impl Write for LoggerLayer {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        let message = String::from_utf8_lossy(buf).to_string();
+        let _ = self.log_sender.send((message, MessageType::LOG));
+        Ok(buf.len())
     }
 
-    fn log(&self, record: &Record) {
-        if self.enabled(record.metadata()) {
-            let message = format!("{} - {}", record.level(), record.args());
-            let message_type = match record.level() {
-                log::Level::Error => MessageType::ERROR,
-                log::Level::Warn => MessageType::WARNING,
-                log::Level::Info => MessageType::INFO,
-                log::Level::Debug => MessageType::LOG,
-                log::Level::Trace => MessageType::LOG,
-            };
-            self.log_sender.send((message, message_type)).unwrap();
-        }
+    fn flush(&mut self) -> std::io::Result<()> {
+        Ok(())
     }
+}
 
-    fn flush(&self) {}
+impl MakeWriter<'_> for LoggerLayer {
+    type Writer = Self;
+    fn make_writer(&self) -> Self::Writer {
+        self.clone()
+    }
 }
 
 pub fn setup_logger(
-    level: Level,
-) -> Result<tokio::sync::mpsc::UnboundedReceiver<(String, MessageType)>, SetLoggerError> {
+    level: tracing::Level,
+) -> Result<tokio::sync::mpsc::UnboundedReceiver<(String, MessageType)>, Box<dyn std::error::Error>>
+{
     let (log_sender, log_receiver) =
         tokio::sync::mpsc::unbounded_channel::<(String, MessageType)>();
-    let logger = Logger { level, log_sender };
-    let static_logger = Box::leak(Box::new(logger));
-    log::set_logger(static_logger)?;
-    log::set_max_level(LevelFilter::Debug);
-    Ok(log_receiver)
-}
+    let logger = LoggerLayer { log_sender };
+    let logger = logger.with_max_level(level);
 
-pub async fn handle_log_messages(
-    mut rx: tokio::sync::mpsc::UnboundedReceiver<(String, MessageType)>,
-    client: Client,
-) -> tokio::sync::mpsc::UnboundedReceiver<String> {
-    loop {
-        let (message, message_type) = rx.recv().await.unwrap();
-        client.log_message(message_type, message).await;
-        yield_now().await;
-    }
+    let pretty_logger = tracing_subscriber::fmt::layer()
+        .event_format(tracing_subscriber::fmt::format::format().pretty())
+        .with_ansi(false)
+        .with_writer(logger);
+
+    let console_layer = console_subscriber::spawn();
+
+    tracing_subscriber::registry()
+        .with(pretty_logger)
+        .with(console_layer)
+        .init();
+
+    Ok(log_receiver)
 }

crates/language-server/src/main.rs

@@ -12,6 +12,7 @@ mod workspace;
 
 use backend::Backend;
 use db::Jar;
+use tracing::Level;
 
 use language_server::Server;
 
@@ -25,9 +26,8 @@ mod handlers {
 async fn main() {
     let stdin = tokio::io::stdin();
     let stdout = tokio::io::stdout();
-    console_subscriber::init();
+    let rx = setup_logger(Level::INFO).unwrap();
 
-    // let message_channels = language_server::MessageChannels::new();
     let (message_senders, message_receivers) = language_server::setup_message_channels();
     let (service, socket) =
         tower_lsp::LspService::build(|client| Server::new(client, message_senders)).finish();
@@ -36,8 +36,6 @@ async fn main() {
     let client = server.client.clone();
     let backend = Backend::new(client, message_receivers);
 
-    let rx = setup_logger(log::Level::Info).unwrap();
-
     // separate runtime for the backend
     // let backend_runtime = tokio::runtime::Builder::new_multi_thread()
     //     .worker_threads(4)

crates/language-server/src/util.rs

@@ -4,8 +4,8 @@ use common::{
 };
 use fxhash::FxHashMap;
 use hir::{hir_def::scope_graph::ScopeId, span::LazySpan, SpannedHirDb};
-use log::error;
 use lsp_types::Position;
+use tracing::error;
 use url::Url;
 
 pub fn calculate_line_offsets(text: &str) -> Vec<usize> {

crates/language-server/src/workspace.rs

@@ -10,8 +10,8 @@ use common::{
     InputFile, InputIngot,
 };
 use hir::{hir_def::TopLevelMod, lower::map_file_to_mod, LowerHirDb};
-use log::info;
 use patricia_tree::StringPatriciaMap;
+use tracing::info;
 
 use crate::db::LanguageServerDatabase;