Improve logging system using logLevel, avoid trace value

crates/red_knot_server/src/lib.rs

@@ -11,10 +11,10 @@ use crate::server::Server;
 mod message;
 
 mod edit;
+mod logging;
 mod server;
 mod session;
 mod system;
-mod trace;
 
 pub(crate) const SERVER_NAME: &str = "red-knot";
 pub(crate) const DIAGNOSTIC_NAME: &str = "Red Knot";

crates/red_knot_server/src/logging.rs

@@ -0,0 +1,114 @@
+//! The logging system for `red_knot server`.
+//!
+//! Log messages are controlled by the `logLevel` setting which defaults to `"info"`. Log messages
+//! are written to `stderr` by default, which should appear in the logs for most LSP clients. A
+//! `logFile` path can also be specified in the settings, and output will be directed there
+//! instead.
+use core::str;
+use serde::Deserialize;
+use std::{path::PathBuf, str::FromStr, sync::Arc};
+use tracing::level_filters::LevelFilter;
+use tracing_subscriber::{
+    fmt::{time::Uptime, writer::BoxMakeWriter},
+    layer::SubscriberExt,
+    Layer,
+};
+
+pub(crate) fn init_logging(log_level: LogLevel, log_file: Option<&std::path::Path>) {
+    let log_file = log_file
+        .map(|path| {
+            // this expands `logFile` so that tildes and environment variables
+            // are replaced with their values, if possible.
+            if let Some(expanded) = shellexpand::full(&path.to_string_lossy())
+                .ok()
+                .and_then(|path| PathBuf::from_str(&path).ok())
+            {
+                expanded
+            } else {
+                path.to_path_buf()
+            }
+        })
+        .and_then(|path| {
+            std::fs::OpenOptions::new()
+                .create(true)
+                .append(true)
+                .open(&path)
+                .map_err(|err| {
+                    #[allow(clippy::print_stderr)]
+                    {
+                        eprintln!(
+                            "Failed to open file at {} for logging: {err}",
+                            path.display()
+                        );
+                    }
+                })
+                .ok()
+        });
+
+    let logger = match log_file {
+        Some(file) => BoxMakeWriter::new(Arc::new(file)),
+        None => BoxMakeWriter::new(std::io::stderr),
+    };
+    let subscriber = tracing_subscriber::Registry::default().with(
+        tracing_subscriber::fmt::layer()
+            .with_timer(Uptime::default())
+            .with_thread_names(true)
+            .with_ansi(false)
+            .with_writer(logger)
+            .with_filter(LogLevelFilter { filter: log_level }),
+    );
+
+    tracing::subscriber::set_global_default(subscriber)
+        .expect("should be able to set global default subscriber");
+}
+
+/// The log level for the server as provided by the client during initialization.
+///
+/// The default log level is `info`.
+#[derive(Clone, Copy, Debug, Deserialize, Default, PartialEq, Eq, PartialOrd, Ord)]
+#[serde(rename_all = "lowercase")]
+pub(crate) enum LogLevel {
+    Error,
+    Warn,
+    #[default]
+    Info,
+    Debug,
+    Trace,
+}
+
+impl LogLevel {
+    fn trace_level(self) -> tracing::Level {
+        match self {
+            Self::Error => tracing::Level::ERROR,
+            Self::Warn => tracing::Level::WARN,
+            Self::Info => tracing::Level::INFO,
+            Self::Debug => tracing::Level::DEBUG,
+            Self::Trace => tracing::Level::TRACE,
+        }
+    }
+}
+
+/// Filters out traces which have a log level lower than the `logLevel` set by the client.
+struct LogLevelFilter {
+    filter: LogLevel,
+}
+
+impl<S> tracing_subscriber::layer::Filter<S> for LogLevelFilter {
+    fn enabled(
+        &self,
+        meta: &tracing::Metadata<'_>,
+        _: &tracing_subscriber::layer::Context<'_, S>,
+    ) -> bool {
+        let filter = if meta.target().starts_with("red_knot") {
+            self.filter.trace_level()
+        } else {
+            tracing::Level::INFO
+        };
+
+        meta.level() <= &filter
+    }
+
+    fn max_level_hint(&self) -> Option<tracing::level_filters::LevelFilter> {
+        Some(LevelFilter::from_level(self.filter.trace_level()))
+    }
+}

crates/red_knot_server/src/server.rs

@@ -51,10 +51,6 @@ impl Server {
             crate::version(),
         )?;
 
-        if let Some(trace) = init_params.trace {
-            crate::trace::set_trace_value(trace);
-        }
-
         crate::message::init_messenger(connection.make_sender());
 
         let AllSettings {
@@ -66,14 +62,9 @@ impl Server {
                 .unwrap_or_else(|| serde_json::Value::Object(serde_json::Map::default())),
         );
 
-        crate::trace::init_tracing(
-            connection.make_sender(),
-            global_settings
-                .tracing
-                .log_level
-                .unwrap_or(crate::trace::LogLevel::Info),
+        crate::logging::init_logging(
+            global_settings.tracing.log_level.unwrap_or_default(),
             global_settings.tracing.log_file.as_deref(),
-            init_params.client_info.as_ref(),
         );
 
         let mut workspace_for_url = |url: Url| {

crates/red_knot_server/src/server/api.rs

@@ -52,9 +52,6 @@ pub(super) fn notification<'a>(notif: server::Notification) -> Task<'a> {
         notification::DidCloseNotebookHandler::METHOD => {
             local_notification_task::<notification::DidCloseNotebookHandler>(notif)
         }
-        notification::SetTraceHandler::METHOD => {
-            local_notification_task::<notification::SetTraceHandler>(notif)
-        }
         method => {
             tracing::warn!("Received notification {method} which does not have a handler.");
             return Task::nothing();

crates/red_knot_server/src/server/api/notifications.rs

@@ -3,11 +3,9 @@ mod did_close;
 mod did_close_notebook;
 mod did_open;
 mod did_open_notebook;
-mod set_trace;
 
 pub(super) use did_change::DidChangeTextDocumentHandler;
 pub(super) use did_close::DidCloseTextDocumentHandler;
 pub(super) use did_close_notebook::DidCloseNotebookHandler;
 pub(super) use did_open::DidOpenTextDocumentHandler;
 pub(super) use did_open_notebook::DidOpenNotebookHandler;
-pub(super) use set_trace::SetTraceHandler;

crates/red_knot_server/src/session/settings.rs

@@ -24,7 +24,7 @@ pub struct ClientSettings {
 #[cfg_attr(test, derive(PartialEq, Eq))]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct TracingSettings {
-    pub(crate) log_level: Option<crate::trace::LogLevel>,
+    pub(crate) log_level: Option<crate::logging::LogLevel>,
     /// Path to the log file - tildes and environment variables are supported.
     pub(crate) log_file: Option<PathBuf>,
 }