feat: cleaner logging

- less clutter with unusable `span` info (on my personal preference)
- less errors logged when being scanned (ex.: after status response
    don't log errors with ping packets, scanners usually close
    the connection)
- implemented more detailed OpaqueError fields
    - `tracing::Level`
    - error `kind`

src/main.rs

@@ -58,12 +58,35 @@ async fn main() {
                 "Client connected"
             );
             if let Err(e) = process_connection(socket, addr, api, config).await {
-                tracing::error!(
-                    // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
-                    trace = format!("{}", e.get_span_trace()),
-                    err = format!("{}", e.context),
-                    "Client disconnected"
-                );
+                match e.level {
+                    tracing::Level::ERROR => tracing::error!(
+                        // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
+                        trace = format!("{}", e.get_span_trace()),
+                        err = format!("{}", e.context),
+                        "Client disconnected"
+                    ),
+                    tracing::Level::WARN => tracing::warn!(
+                        // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
+                        trace = format!("{}", e.get_span_trace()),
+                        err = format!("{}", e.context),
+                        "Client disconnected"
+                    ),
+                    tracing::Level::INFO => tracing::info!(
+                        // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
+                        trace = format!("{}", e.get_span_trace()),
+                        err = format!("{}", e.context),
+                        "Client disconnected"
+                    ),
+                    _ => {
+                        tracing::error!(
+                            // addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
+                            trace = format!("{}", e.get_span_trace()),
+                            err = format!("{}", e.context),
+                            actual_level = ?e.level,
+                            "Client disconnected (bad level)"
+                        )
+                    }
+                }
             } else {
                 tracing::debug!(
                     addr = format!("{}:{}", addr.ip().to_string(), addr.port().to_string()),
@@ -74,7 +97,6 @@ async fn main() {
     }
 }
 
-#[tracing::instrument(level = "info", skip(api, client_stream, config))]
 async fn process_connection<T: MinecraftServerHandle>(
     mut client_stream: TcpStream,
     addr: SocketAddr,
@@ -159,7 +181,6 @@ async fn handle_status<T: MinecraftServerHandle>(
     };
 
     let server_addr = handshake.get_server_address();
-    let commit_hash: &'static str = env!("COMMIT_HASH");
     let mut status_struct = StatusStructNew::create();
     status_struct.version.protocol = handshake.protocol_version.get_int();
 
@@ -172,7 +193,7 @@ async fn handle_status<T: MinecraftServerHandle>(
     {
         Ok(x) => x,
         Err(e) => {
-            let span = tracing::span!(tracing::Level::WARN, "not_found", err = e.context);
+            let span = tracing::span!(tracing::Level::INFO, "unavailable", err = e.get_kind());
             status_struct.players.max = 0;
             status_struct.players.online = 0;
             status_struct.description.text = format!(
@@ -184,22 +205,25 @@ async fn handle_status<T: MinecraftServerHandle>(
                 .await?;
 
             // Recieve the ping packet, so the client does not send it again
-            let _ping = Packet::parse(client_stream).instrument(span.clone()).await;
+            let _ping = Packet::parse(client_stream)
+                .instrument(span.clone())
+                .await
+                .map_err(|err| {
+                    tracing::debug!(
+                        err = OpaqueError::from(err).context,
+                        "failed to parse ping packet"
+                    )
+                });
             // Send a bad ping packet back, so the client shows *searching* icon
             let _pong = Packet::new(9, vec![0; 8])
                 .ok_or("failed to create empty pong packet?")?
                 .send_packet(client_stream)
                 .instrument(span.clone())
                 .await
-                .map_err(|_| "failed to send pong packet")?;
+                .map_err(|_| tracing::debug!("failed to send pong packet"));
             let _guard = span.enter();
 
-            match _ping {
-                Ok(_) => tracing::info!("sent status with error"),
-                Err(err) => {
-                    tracing::error!(err = OpaqueError::from(err).context)
-                }
-            };
+            tracing::info!(status = "unavailable", "status request");
             return Ok(());
         }
     };
@@ -209,7 +233,6 @@ async fn handle_status<T: MinecraftServerHandle>(
         .get_motd()
         .unwrap_or("A minecraft server (proxy motd)".to_string());
 
-    tracing::trace!(motd);
     match status {
         ServerDeploymentStatus::Connectable(mut server_stream) => {
             return server
@@ -245,7 +268,8 @@ async fn handle_login<T: MinecraftServerHandle>(
             &handshake.get_server_address(),
             &handshake.server_port.get_value().to_string(),
         )
-        .await?;
+        .await
+        .map_err(|e| e.set_level(tracing::Level::WARN))?;
 
     let status = server.query_status().await?;
     tracing::debug!(msg = "server status", status = ?status);
@@ -281,12 +305,20 @@ async fn handle_login<T: MinecraftServerHandle>(
                 .execute(client_stream, &mut server_stream)
                 .await;
 
-            tracing::debug!("data exchanged: tx: {} rx: {}", traffic.tx, traffic.rx);
-            if let Some(e) = traffic.error {
-                return Err(OpaqueError::create(&format!(
-                    "failed to splice; err = {}",
-                    e
-                )));
+            match traffic.error {
+                Some(e) => {
+                    tracing::info!(
+                        tx = traffic.tx,
+                        rx = traffic.rx,
+                        err = ?e,
+                        "connection splicing ended with error",
+                    )
+                }
+                None => tracing::info!(
+                    tx = traffic.tx,
+                    rx = traffic.rx,
+                    "connection splicing ended",
+                ),
             }
         }
         ServerDeploymentStatus::PodOk | ServerDeploymentStatus::Starting => {