Clean up use of utility wrapper to log file/line numbers for tracing

bsodmike · bsodmike · commit 6a97f1679e58 · 2022-01-17T14:17:10.000+05:30
This was just added to tracing (tokio-rs/tracing#1773) and the wrapper can be updated to leverage the same.
diff --git a/src/errors.rs b/src/errors.rs
@@ -1,5 +1,10 @@
 use async_session;
-use axum::{http::StatusCode, Json};
+use axum::{
+    body::{boxed, Full},
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
 use serde_json::{error, json, Value};
 use std::io;
 use thiserror::Error;
@@ -22,6 +27,14 @@ pub enum CustomError {
 pub type ApiError = (StatusCode, Json<Value>);
 pub type ApiResult<T> = std::result::Result<T, ApiError>;
 
+impl IntoResponse for CustomError {
+    fn into_response(self) -> Response {
+        let mut res = Response::new(boxed(Full::from(self.to_string())));
+        *res.status_mut() = StatusCode::BAD_REQUEST;
+        res
+    }
+}
+
 impl From<hyper::Error> for CustomError {
     fn from(err: hyper::Error) -> CustomError {
         CustomError::HyperError
diff --git a/src/extractors/user_extractor.rs b/src/extractors/user_extractor.rs
@@ -72,7 +72,8 @@ where
                     std::panic::Location::caller(),
                     format!("Unable to fetch user from session!"),
                 )
-                .await;
+                .await
+                .into_response();
 
                 return Err(StatusCode::INTERNAL_SERVER_ERROR);
             }
diff --git a/src/handlers.rs b/src/handlers.rs
@@ -91,7 +91,8 @@ pub async fn handle_form(req: Request<Body>) -> impl IntoResponse {
         std::panic::Location::caller(),
         format!("handle_form: Body {:?}", body_deserialized),
     )
-    .await;
+    .await
+    .into_response();
 
     let store = &mut req_parts
         .extensions()
diff --git a/src/session.rs b/src/session.rs
@@ -77,7 +77,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i
                     std::panic::Location::caller(),
                     format!("Error: Unable to update session with user {:?}", err),
                 )
-                .await;
+                .await
+                .into_response();
 
                 return Err(StatusCode::INTERNAL_SERVER_ERROR);
             }
@@ -95,7 +96,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i
                         std::panic::Location::caller(),
                         format!("Unable to fetch cookie value from new session!"),
                     )
-                    .await;
+                    .await
+                    .into_response();
 
                     return Err(StatusCode::INTERNAL_SERVER_ERROR);
                 }
@@ -105,7 +107,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i
                     std::panic::Location::caller(),
                     format!("Error whilst attempting to update store {:?}", err),
                 )
-                .await;
+                .await
+                .into_response();
 
                 return Err(StatusCode::INTERNAL_SERVER_ERROR);
             }
@@ -115,7 +118,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i
             std::panic::Location::caller(),
             format!("Updated Session: {:?}", &session_clone.id()),
         )
-        .await;
+        .await
+        .into_response();
 
         tracing::debug!(
             "Created cookie {:?}={:?} for UUID {} / for Session: {:?}",
@@ -194,7 +198,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i
                         session_cookie_clone
                     ),
                 )
-                .await;
+                .await
+                .into_response();
 
                 return Err(StatusCode::BAD_REQUEST);
             }
@@ -265,7 +270,7 @@ where
                 std::panic::Location::caller(),
                 format!("Error: Unable to deserialize request body {:?}", err),
             )
-            .await;
+            .await?;
 
             return Err(CustomError::NotImplementedError);
         }
@@ -298,7 +303,7 @@ pub async fn update(
             &session_cookie
         ),
     )
-    .await;
+    .await?;
 
     // Use `session_cookie` to load the session
     let mut session: Session = match store.load_session(session_cookie.to_string()).await {
@@ -309,7 +314,7 @@ pub async fn update(
                     std::panic::Location::caller(),
                     format!("Error: Unable to load session!"),
                 )
-                .await;
+                .await?;
                 return Err(CustomError::NotImplementedError);
             }
         },
@@ -327,7 +332,7 @@ pub async fn update(
                 std::panic::Location::caller(),
                 format!("Error: Unable to update session with user {:?}", err),
             )
-            .await;
+            .await?;
 
             return Err(CustomError::NotImplementedError);
         }
@@ -343,7 +348,7 @@ pub async fn update(
                         cookie_value
                     ),
                 )
-                .await;
+                .await?;
 
                 cookie_value
             }
@@ -352,7 +357,7 @@ pub async fn update(
                     std::panic::Location::caller(),
                     format!("Store updated OK / No cookie value returned"),
                 )
-                .await;
+                .await?;
 
                 String::from("")
             }
@@ -362,7 +367,7 @@ pub async fn update(
                 std::panic::Location::caller(),
                 format!("Error whilst attempting to update store {:?}", err),
             )
-            .await;
+            .await?;
 
             return Err(CustomError::NotImplementedError);
         }
@@ -398,7 +403,7 @@ where
             &session_cookie
         ),
     )
-    .await;
+    .await?;
 
     // Use `session_cookie` to load the session
     let session: Session = match store.load_session(session_cookie.to_string()).await {
@@ -409,7 +414,7 @@ where
                     std::panic::Location::caller(),
                     format!("Error: Unable to load session!"),
                 )
-                .await;
+                .await?;
                 return Err(CustomError::NotImplementedError);
             }
         },
@@ -425,7 +430,7 @@ where
                 std::panic::Location::caller(),
                 format!("Unable to fetch user from session!"),
             )
-            .await;
+            .await?;
 
             return Err(CustomError::NotImplementedError);
         }
diff --git a/src/utils.rs b/src/utils.rs
@@ -1,14 +1,25 @@
+use crate::errors::CustomError;
 use anyhow::Error;
 use std::panic::Location;
 
-pub async fn tracing_debug(location: &'static Location<'static>, msg: String) {
+pub async fn tracing_debug(
+    location: &'static Location<'static>,
+    msg: String,
+) -> Result<(), CustomError> {
     let custom_format = format!("[{}:{}]", location.file(), location.line());
 
     tracing::debug!("{}: {}", custom_format, msg);
+
+    Ok(())
 }
 
-pub async fn tracing_error(location: &'static Location<'static>, msg: String) {
+pub async fn tracing_error(
+    location: &'static Location<'static>,
+    msg: String,
+) -> Result<(), CustomError> {
     let custom_format = format!("[{}:{}]", location.file(), location.line());
 
     tracing::error!("{}: {}", custom_format, msg);
+
+    Ok(())
 }

Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,8 @@ where`
`72`	`72`	`std::panic::Location::caller(),`
`73`	`73`	`format!("Unable to fetch user from session!"),`
`74`	`74`	`)`
`75`		`- .await;`
	`75`	`+ .await`
	`76`	`+ .into_response();`
`76`	`77`
`77`	`78`	`return Err(StatusCode::INTERNAL_SERVER_ERROR);`
`78`	`79`	`}`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,8 @@ pub async fn handle_form(req: Request<Body>) -> impl IntoResponse {`
`91`	`91`	`std::panic::Location::caller(),`
`92`	`92`	`format!("handle_form: Body {:?}", body_deserialized),`
`93`	`93`	`)`
`94`		`- .await;`
	`94`	`+ .await`
	`95`	`+ .into_response();`
`95`	`96`
`96`	`97`	`let store = &mut req_parts`
`97`	`98`	`.extensions()`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i`
`77`	`77`	`std::panic::Location::caller(),`
`78`	`78`	`format!("Error: Unable to update session with user {:?}", err),`
`79`	`79`	`)`
`80`		`- .await;`
	`80`	`+ .await`
	`81`	`+ .into_response();`
`81`	`82`
`82`	`83`	`return Err(StatusCode::INTERNAL_SERVER_ERROR);`
`83`	`84`	`}`
`@@ -95,7 +96,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i`
`95`	`96`	`std::panic::Location::caller(),`
`96`	`97`	`format!("Unable to fetch cookie value from new session!"),`
`97`	`98`	`)`
`98`		`- .await;`
	`99`	`+ .await`
	`100`	`+ .into_response();`
`99`	`101`
`100`	`102`	`return Err(StatusCode::INTERNAL_SERVER_ERROR);`
`101`	`103`	`}`
`@@ -105,7 +107,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i`
`105`	`107`	`std::panic::Location::caller(),`
`106`	`108`	`format!("Error whilst attempting to update store {:?}", err),`
`107`	`109`	`)`
`108`		`- .await;`
	`110`	`+ .await`
	`111`	`+ .into_response();`
`109`	`112`
`110`	`113`	`return Err(StatusCode::INTERNAL_SERVER_ERROR);`
`111`	`114`	`}`
`@@ -115,7 +118,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i`
`115`	`118`	`std::panic::Location::caller(),`
`116`	`119`	`format!("Updated Session: {:?}", &session_clone.id()),`
`117`	`120`	`)`
`118`		`- .await;`
	`121`	`+ .await`
	`122`	`+ .into_response();`
`119`	`123`
`120`	`124`	`tracing::debug!(`
`121`	`125`	`"Created cookie {:?}={:?} for UUID {} / for Session: {:?}",`
`@@ -194,7 +198,8 @@ pub async fn session_uuid_middleware<B>(mut req: Request<B>, next: Next<B>) -> i`
`194`	`198`	`session_cookie_clone`
`195`	`199`	`),`
`196`	`200`	`)`
`197`		`- .await;`
	`201`	`+ .await`
	`202`	`+ .into_response();`
`198`	`203`
`199`	`204`	`return Err(StatusCode::BAD_REQUEST);`
`200`	`205`	`}`
`@@ -265,7 +270,7 @@ where`
`265`	`270`	`std::panic::Location::caller(),`
`266`	`271`	`format!("Error: Unable to deserialize request body {:?}", err),`
`267`	`272`	`)`
`268`		`- .await;`
	`273`	`+ .await?;`
`269`	`274`
`270`	`275`	`return Err(CustomError::NotImplementedError);`
`271`	`276`	`}`
`@@ -298,7 +303,7 @@ pub async fn update(`
`298`	`303`	`&session_cookie`
`299`	`304`	`),`
`300`	`305`	`)`
`301`		`- .await;`
	`306`	`+ .await?;`
`302`	`307`
`303`	`308`	// Use `session_cookie` to load the session
`304`	`309`	`let mut session: Session = match store.load_session(session_cookie.to_string()).await {`
`@@ -309,7 +314,7 @@ pub async fn update(`
`309`	`314`	`std::panic::Location::caller(),`
`310`	`315`	`format!("Error: Unable to load session!"),`
`311`	`316`	`)`
`312`		`- .await;`
	`317`	`+ .await?;`
`313`	`318`	`return Err(CustomError::NotImplementedError);`
`314`	`319`	`}`
`315`	`320`	`},`
`@@ -327,7 +332,7 @@ pub async fn update(`
`327`	`332`	`std::panic::Location::caller(),`
`328`	`333`	`format!("Error: Unable to update session with user {:?}", err),`
`329`	`334`	`)`
`330`		`- .await;`
	`335`	`+ .await?;`
`331`	`336`
`332`	`337`	`return Err(CustomError::NotImplementedError);`
`333`	`338`	`}`
`@@ -343,7 +348,7 @@ pub async fn update(`
`343`	`348`	`cookie_value`
`344`	`349`	`),`
`345`	`350`	`)`
`346`		`- .await;`
	`351`	`+ .await?;`
`347`	`352`
`348`	`353`	`cookie_value`
`349`	`354`	`}`
`@@ -352,7 +357,7 @@ pub async fn update(`
`352`	`357`	`std::panic::Location::caller(),`
`353`	`358`	`format!("Store updated OK / No cookie value returned"),`
`354`	`359`	`)`
`355`		`- .await;`
	`360`	`+ .await?;`
`356`	`361`
`357`	`362`	`String::from("")`
`358`	`363`	`}`
`@@ -362,7 +367,7 @@ pub async fn update(`
`362`	`367`	`std::panic::Location::caller(),`
`363`	`368`	`format!("Error whilst attempting to update store {:?}", err),`
`364`	`369`	`)`
`365`		`- .await;`
	`370`	`+ .await?;`
`366`	`371`
`367`	`372`	`return Err(CustomError::NotImplementedError);`
`368`	`373`	`}`
`@@ -398,7 +403,7 @@ where`
`398`	`403`	`&session_cookie`
`399`	`404`	`),`
`400`	`405`	`)`
`401`		`- .await;`
	`406`	`+ .await?;`
`402`	`407`
`403`	`408`	// Use `session_cookie` to load the session
`404`	`409`	`let session: Session = match store.load_session(session_cookie.to_string()).await {`
`@@ -409,7 +414,7 @@ where`
`409`	`414`	`std::panic::Location::caller(),`
`410`	`415`	`format!("Error: Unable to load session!"),`
`411`	`416`	`)`
`412`		`- .await;`
	`417`	`+ .await?;`
`413`	`418`	`return Err(CustomError::NotImplementedError);`
`414`	`419`	`}`
`415`	`420`	`},`
`@@ -425,7 +430,7 @@ where`
`425`	`430`	`std::panic::Location::caller(),`
`426`	`431`	`format!("Unable to fetch user from session!"),`
`427`	`432`	`)`
`428`		`- .await;`
	`433`	`+ .await?;`
`429`	`434`
`430`	`435`	`return Err(CustomError::NotImplementedError);`
`431`	`436`	`}`