Reduce logging noise

src/main.rs

@@ -55,7 +55,7 @@ fn main() -> Result<()> {
     color_eyre::install()?;
     tracing_subscriber::registry()
         .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| "info".into()))
-        .with(fmt::layer().pretty())
+        .with(fmt::layer().compact())
         .with(ErrorLayer::new(fmt::format::Pretty::default()))
         .init();
 

src/worker/api.rs

@@ -1,12 +1,13 @@
-use std::ascii::AsciiExt;
+use std::collections::HashMap;
+use std::sync::mpsc::Sender;
 use std::time::Duration;
-use std::{collections::HashMap, sync::mpsc::Sender};
 
 use color_eyre::eyre::Context as _;
 use color_eyre::Result;
 use reqwest::{header, Client};
 use tokio::runtime;
 use tokio::sync::mpsc::UnboundedReceiver;
+use tracing::Instrument as _;
 
 use crate::types::{ApiEvent, ApiTask, Event, Method};
 use crate::APP_USER_AGENT;
@@ -21,6 +22,7 @@ fn header_map_to_hashmap(headers: &header::HeaderMap) -> HashMap<String, Vec<u8>
     map
 }
 
+#[tracing::instrument]
 async fn perform_request(client: &Client, task: &ApiTask) -> Result<Event> {
     let req = match task.method {
         Method::Get => client.get(&task.url),
@@ -55,10 +57,8 @@ async fn perform_request(client: &Client, task: &ApiTask) -> Result<Event> {
     let headers = header_map_to_hashmap(res.headers());
 
     let body: serde_json::Value = if let Ok(text) = res.text().await {
-        tracing::trace!("Response body: {}", text);
         serde_json::from_str(&text).unwrap_or(serde_json::Value::String(text))
     } else {
-        tracing::trace!("Response body: NULL");
         serde_json::Value::Null
     };
 
@@ -81,9 +81,10 @@ pub async fn run(mut api_rx: UnboundedReceiver<ApiTask>, event_tx: Sender<Event>
         .wrap_err("Failed to build HTTP client")?;
 
     tokio::spawn({
+        let span = tracing::info_span!("api receiver");
         async move {
             while let Some(task) = api_rx.recv().await {
-                tracing::trace!("Received new API task: {:?}", task);
+                tracing::trace!(id = task.id, "Received new API task");
 
                 let _ = task_tx
                     .send(async move {
@@ -94,6 +95,7 @@ pub async fn run(mut api_rx: UnboundedReceiver<ApiTask>, event_tx: Sender<Event>
             }
             tracing::error!("API task channel closed");
         }
+        .instrument(span)
     });
 
     while let Some(task) = task_rx.recv().await {

src/worker/lua.rs

@@ -4,7 +4,7 @@ use color_eyre::Result;
 use mlua::{Function, IntoLua as _, Lua, LuaSerdeExt};
 use tokio::sync::mpsc::UnboundedSender;
 
-use crate::types::{ApiTask, Event, Message};
+use crate::types::{ApiTask, Event, Message, NtfyMessage};
 
 #[tracing::instrument(skip_all)]
 pub fn worker(
@@ -48,8 +48,8 @@ pub fn worker(
         log_tbl.set("error", log_error_fn)?;
 
         let ntfy_fn = scope.create_function_mut(|_, data: mlua::Value| {
-            let data = lua.from_value(data)?;
+            let data: NtfyMessage = lua.from_value(data)?;
-            tracing::trace!("Sending Ntfy message: {:?}", data);
+            tracing::trace!(topic = data.topic, title = data.title, msg = data.message,"Sending Ntfy message");
 
             match ntfy_tx.send(Message::Ntfy(data)) {
                 Ok(_) => Ok((true, mlua::Value::Nil)),
@@ -61,8 +61,8 @@ pub fn worker(
         })?;
 
         let set_api_task_fn = scope.create_function_mut(|_, data: mlua::Value| {
-            let task = lua.from_value(data)?;
+            let task: ApiTask = lua.from_value(data)?;
-            tracing::trace!("Sending task request: {:?}", task);
+            tracing::trace!("Sending task request: id = {}, delay = {}", task.id, task.delay);
 
             match api_tx.send(task) {
                 Ok(_) => Ok((true, mlua::Value::Nil)),
@@ -92,17 +92,19 @@ pub fn worker(
 
         // Main blocking loop. As long as we can receive events, this scope will stay active.
         while let Ok(event) = event_rx.recv() {
-            tracing::trace!("Received event: {:?}", event);
             match event {
                 Event::Webhook(data) => {
+                    tracing::trace!(id = data.topic, "Received webhook event");
                     let data = lua.to_value(&data)?;
                     event_fn.call::<_, ()>(("webhook", data))?
                 }
                 Event::Api(data) => {
+                    tracing::trace!(id = data.id, status = data.status, "Received api event");
                     let data = data.into_lua(&lua)?;
                     event_fn.call::<_, ()>(("api", data))?
                 }
                 Event::Error(data) => {
+                    tracing::trace!(id = data.id, message = data.message, "Received error event");
                     let data = lua.to_value(&data)?;
                     event_fn.call::<_, ()>(("error", data))?
                 }

src/worker/sender.rs

@@ -44,10 +44,9 @@ pub async fn run(event_tx: Sender<Event>, mut ntfy_rx: UnboundedReceiver<Message
     let ntfy_client = Client::builder().user_agent(APP_USER_AGENT).build()?;
 
     while let Some(message) = ntfy_rx.recv().await {
-        tracing::trace!("Received notification: {:?}", message);
-
         match message {
             Message::Ntfy(data) => {
+                tracing::trace!(topic = data.topic, "Sending Ntfy notification");
                 if let Err(err) = send_ntfy(&ntfy_client, &data).await {
                     tracing::error!("Failed to send to Ntfy: {:?}", err);
                     event_tx.send(Event::error(data.topic, err))?;