allow changing log filtering while node runs

This also changes the default to tracing-subscriber.

4 files changed, 97 insertions, 1 deletions

diff --git a/src/api/log.rs b/src/api/log.rs
new file mode 100644
index 0000000..5d44926
--- /dev/null
+++ b/src/api/log.rs
@@ -0,0 +1,32 @@
+//! /admin/log: read and replace the log filter of the running node.
+
+use axum::{body::Bytes, http::StatusCode};
+use tracing::{info, warn};
+
+use crate::logging;
+
+/// `GET /admin/log`: the filter in effect, as plain text in `RUST_LOG` syntax.
+pub(crate) async fn get_log_filter() -> Result<String, StatusCode> {
+    logging::filter().map_err(|error| {
+        warn!(error = %format!("{error:#}"), "Cannot read the log filter");
+        StatusCode::INTERNAL_SERVER_ERROR
+    })
+}
+
+/// `PUT /admin/log`: replace the filter; the body is plain text in `RUST_LOG` syntax,
+/// e.g. `info,continuum::swarm::sync=trace`. Answers with the filter now in effect;
+/// 400 (with the reason) if the body doesn't parse, and the old filter stays.
+pub(crate) async fn put_log_filter(body: Bytes) -> Result<String, (StatusCode, String)> {
+    let directives = std::str::from_utf8(&body)
+        .map_err(|_| {
+            (
+                StatusCode::BAD_REQUEST,
+                "The filter must be UTF-8\n".to_owned(),
+            )
+        })?
+        .trim();
+    let applied = logging::set_filter(directives)
+        .map_err(|error| (StatusCode::BAD_REQUEST, format!("{error:#}\n")))?;
+    info!(filter = %applied, "Log filter replaced");
+    Ok(applied + "\n")
+}
diff --git a/src/api/mod.rs b/src/api/mod.rs
index 2399ec8..a2bd7e0 100644
--- a/src/api/mod.rs
+++ b/src/api/mod.rs
@@ -2,6 +2,7 @@
 
 pub(crate) mod auth;
 mod debug;
+mod log;
 mod peers;
 mod store;
 
@@ -37,6 +38,10 @@ pub(crate) fn router(state: AppState, auth_state: AuthState, debug_api: bool) ->
         .route("/stream/{*key}", get(store::stream_store_entry))
         .route("/peers", get(peers::list_peers))
         .route("/peers/{peer}", delete(peers::delete_peer))
+        .route(
+            "/admin/log",
+            get(log::get_log_filter).put(log::put_log_filter),
+        )
         .merge(crate::remake::router::<AppState>());
 
     if debug_api {
diff --git a/src/logging.rs b/src/logging.rs
new file mode 100644
index 0000000..4496125
--- /dev/null
+++ b/src/logging.rs
@@ -0,0 +1,58 @@
+//! Logging: a compact fmt logger whose filter can be replaced while the node runs
+//! (`/admin/log`), and, with the `tokio-console` feature, a tokio-console layer.
+//!
+//! The filter starts from `RUST_LOG`, or `info` without it. It applies to the fmt
+//! logger only, so the console layer keeps getting the runtime events it needs.
+
+use std::sync::OnceLock;
+
+use anyhow::{Result, anyhow};
+use tracing_subscriber::{EnvFilter, Registry, prelude::*, reload};
+
+type FilterHandle = reload::Handle<EnvFilter, Registry>;
+
+static FILTER: OnceLock<FilterHandle> = OnceLock::new();
+
+/// Installs the global subscriber. Call once, first thing in main.
+pub(crate) fn init() {
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+    let (filter, handle) = reload::Layer::new(filter);
+
+    let registry = tracing_subscriber::registry().with(
+        tracing_subscriber::fmt::layer()
+            .compact()
+            .with_filter(filter),
+    );
+
+    #[cfg(feature = "tokio-console")]
+    let registry = registry
+        .with(console_subscriber::spawn().with_filter(EnvFilter::new("tokio=trace,runtime=trace")));
+
+    registry.init();
+    let _ = FILTER.set(handle);
+}
+
+/// The filter in effect, in `RUST_LOG` syntax.
+pub(crate) fn filter() -> Result<String> {
+    handle()?
+        .with_current(|filter| filter.to_string())
+        .map_err(|error| anyhow!("Reading the log filter: {error}"))
+}
+
+/// Replaces the filter. `directives` uses `RUST_LOG` syntax, e.g.
+/// `info,continuum::swarm::sync=trace`. An invalid one leaves the old filter in place.
+pub(crate) fn set_filter(directives: &str) -> Result<String> {
+    let filter = EnvFilter::try_new(directives)
+        .map_err(|error| anyhow!("Invalid log filter {directives:?}: {error}"))?;
+    let applied = filter.to_string();
+    handle()?
+        .reload(filter)
+        .map_err(|error| anyhow!("Replacing the log filter: {error}"))?;
+    Ok(applied)
+}
+
+fn handle() -> Result<&'static FilterHandle> {
+    FILTER
+        .get()
+        .ok_or_else(|| anyhow!("Logging is not initialised"))
+}
diff --git a/src/main.rs b/src/main.rs
index 1a9d68e..5abc0e2 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -20,6 +20,7 @@ use url::Url;
 
 mod api;
 mod document;
+mod logging;
 mod remake;
 mod state;
 mod swarm;
@@ -97,7 +98,7 @@ struct Args {
 
 #[tokio::main]
 async fn main() -> Result<()> {
-    console_subscriber::init();
+    logging::init();
 
     let args = Args::parse();