diff --git a/crates/common_utils/src/macros.rs b/crates/common_utils/src/macros.rs
index fd33aa3f3b..9491187156 100644
--- a/crates/common_utils/src/macros.rs
+++ b/crates/common_utils/src/macros.rs
@@ -65,7 +65,7 @@ macro_rules! fallback_reverse_lookup_not_found {
         match $a {
             Ok(res) => res,
             Err(err) => {
-                router_env::logger::error!(reverse_lookup_fallback = %err);
+                router_env::logger::error!(reverse_lookup_fallback = ?err);
                 match err.current_context() {
                     errors::StorageError::ValueNotFound(_) => return $b,
                     errors::StorageError::DatabaseError(data_err) => {
diff --git a/crates/drainer/src/handler.rs b/crates/drainer/src/handler.rs
index 77aefb422a..8d6f7260fd 100644
--- a/crates/drainer/src/handler.rs
+++ b/crates/drainer/src/handler.rs
@@ -154,13 +154,13 @@ impl Handler {
 pub async fn redis_error_receiver(rx: oneshot::Receiver<()>, shutdown_channel: mpsc::Sender<()>) {
     match rx.await {
         Ok(_) => {
-            logger::error!("The redis server failed ");
+            logger::error!("The redis server failed");
             let _ = shutdown_channel.send(()).await.map_err(|err| {
                 logger::error!("Failed to send signal to the shutdown channel {err}")
             });
         }
         Err(err) => {
-            logger::error!("Channel receiver error{err}");
+            logger::error!("Channel receiver error {err}");
         }
     }
 }
diff --git a/crates/router/src/bin/scheduler.rs b/crates/router/src/bin/scheduler.rs
index 1afc09e5a6..caa3e039e8 100644
--- a/crates/router/src/bin/scheduler.rs
+++ b/crates/router/src/bin/scheduler.rs
@@ -328,7 +328,7 @@ impl ProcessTrackerWorkflows<routes::SessionState> for WorkflowRunner {
             {
                 Ok(_) => (),
                 Err(error) => {
-                    logger::error!(%error, "Failed while handling error");
+                    logger::error!(?error, "Failed while handling error");
                     let status = state
                         .get_db()
                         .as_scheduler()
@@ -337,8 +337,12 @@ impl ProcessTrackerWorkflows<routes::SessionState> for WorkflowRunner {
                             business_status::GLOBAL_FAILURE,
                         )
                         .await;
-                    if let Err(err) = status {
-                        logger::error!(%err, "Failed while performing database operation: {}", business_status::GLOBAL_FAILURE);
+                    if let Err(error) = status {
+                        logger::error!(
+                            ?error,
+                            "Failed while performing database operation: {}",
+                            business_status::GLOBAL_FAILURE
+                        );
                     }
                 }
             },
diff --git a/crates/router/src/core/blocklist/utils.rs b/crates/router/src/core/blocklist/utils.rs
index baa2e51404..97324effa8 100644
--- a/crates/router/src/core/blocklist/utils.rs
+++ b/crates/router/src/core/blocklist/utils.rs
@@ -74,9 +74,9 @@ pub async fn toggle_blocklist_guard_for_merchant(
                 .change_context(errors::ApiErrorResponse::InternalServerError)
                 .attach_printable("Error enabling the blocklist guard")?;
         }
-        Err(e) => {
-            logger::error!(error=?e);
-            Err(e)
+        Err(error) => {
+            logger::error!(?error);
+            Err(error)
                 .change_context(errors::ApiErrorResponse::InternalServerError)
                 .attach_printable("Error enabling the blocklist guard")?;
         }
@@ -323,8 +323,8 @@ where
         .await
         .attach_printable("error in pm fingerprint creation")
         .map_or_else(
-            |err| {
-                logger::error!(error=?err);
+            |error| {
+                logger::error!(?error);
                 None
             },
             Some,
@@ -469,8 +469,8 @@ pub async fn generate_payment_fingerprint(
             .await
             .attach_printable("error in pm fingerprint creation")
             .map_or_else(
-                |err| {
-                    logger::error!(error=?err);
+                |error| {
+                    logger::error!(?error);
                     None
                 },
                 Some,
diff --git a/crates/router/src/core/payment_methods/cards.rs b/crates/router/src/core/payment_methods/cards.rs
index ef1fa51442..ee6ac7731c 100644
--- a/crates/router/src/core/payment_methods/cards.rs
+++ b/crates/router/src/core/payment_methods/cards.rs
@@ -164,7 +164,7 @@ pub async fn create_payment_method(
             storage_scheme,
         )
         .await
-        .map_err(|err| logger::error!(error=?err,"Failed to set the payment method as default"));
+        .map_err(|error| logger::error!(?error, "Failed to set the payment method as default"));
     }
     Ok(response)
 }
@@ -548,7 +548,7 @@ pub async fn skip_locker_call_and_migrate_payment_method(
             merchant_account.storage_scheme,
         )
         .await
-        .map_err(|err| logger::error!(error=?err,"Failed to set the payment method as default"));
+        .map_err(|error| logger::error!(?error, "Failed to set the payment method as default"));
     }
     Ok(services::api::ApplicationResponse::Json(
         api::PaymentMethodResponse::foreign_from((card, response)),
@@ -822,11 +822,16 @@ pub async fn add_payment_method_data(
                                 merchant_account.merchant_id.clone(),
                                 key_store.clone(),
                                 &customer_id,
-                               pm_id,
-                               merchant_account.storage_scheme,
+                                pm_id,
+                                merchant_account.storage_scheme,
                             )
                             .await
-                            .map_err(|err| logger::error!(error=?err,"Failed to set the payment method as default"));
+                            .map_err(|error| {
+                                logger::error!(
+                                    ?error,
+                                    "Failed to set the payment method as default"
+                                )
+                            });
                         }
 
                         return Ok(services::ApplicationResponse::Json(pm_resp));
@@ -1421,7 +1426,7 @@ pub async fn add_bank_to_locker(
     let enc_data = async {
         serde_json::to_value(payout_method_data.to_owned())
             .map_err(|err| {
-                logger::error!("Error while encoding payout method data: {}", err);
+                logger::error!("Error while encoding payout method data: {err:?}");
                 errors::VaultError::SavePaymentMethodFailed
             })
             .change_context(errors::VaultError::SavePaymentMethodFailed)
@@ -2621,8 +2626,8 @@ pub async fn list_payment_methods(
                             .attach_printable("Failed to deserialize Payment Method Auth config")
                     })
                     .transpose()
-                    .unwrap_or_else(|err| {
-                        logger::error!(error=?err);
+                    .unwrap_or_else(|error| {
+                        logger::error!(?error);
                         None
                     });
 
@@ -2665,8 +2670,8 @@ pub async fn list_payment_methods(
             rc.serialize_and_set_key_with_expiry(pm_auth_key.as_str(), val, redis_expiry)
                 .await
                 .attach_printable("Failed to store pm auth data in redis")
-                .unwrap_or_else(|err| {
-                    logger::error!(error=?err);
+                .unwrap_or_else(|error| {
+                    logger::error!(?error);
                 })
         };
 
@@ -3344,17 +3349,20 @@ pub async fn filter_payment_methods(
         if let Ok(payment_methods_enabled) = parse_result {
             let payment_method = payment_methods_enabled.payment_method;
 
-            let allowed_payment_method_types = payment_intent
-                .and_then(|payment_intent| {
-                    payment_intent
-                        .allowed_payment_method_types
-                        .clone()
-                        .map(|val| val.parse_value("Vec<PaymentMethodType>"))
-                        .transpose()
-                        .unwrap_or_else(|error| {
-                            logger::error!(%error, "Failed to deserialize PaymentIntent allowed_payment_method_types"); None
-                        })
-                });
+            let allowed_payment_method_types = payment_intent.and_then(|payment_intent| {
+                payment_intent
+                    .allowed_payment_method_types
+                    .clone()
+                    .map(|val| val.parse_value("Vec<PaymentMethodType>"))
+                    .transpose()
+                    .unwrap_or_else(|error| {
+                        logger::error!(
+                            ?error,
+                            "Failed to deserialize PaymentIntent allowed_payment_method_types"
+                        );
+                        None
+                    })
+            });
 
             for payment_method_type_info in payment_methods_enabled
                 .payment_method_types
@@ -3741,8 +3749,8 @@ pub async fn list_customer_payment_method(
                 // Retrieve the pm_auth connector details so that it can be tokenized
                 let bank_account_token_data = get_bank_account_connector_details(&pm, key)
                     .await
-                    .unwrap_or_else(|err| {
-                        logger::error!(error=?err);
+                    .unwrap_or_else(|error| {
+                        logger::error!(?error);
                         None
                     });
                 if let Some(data) = bank_account_token_data {
@@ -3802,8 +3810,8 @@ pub async fn list_customer_payment_method(
         let bank_details = if payment_method == enums::PaymentMethod::BankDebit {
             get_masked_bank_details(&pm, key)
                 .await
-                .unwrap_or_else(|err| {
-                    logger::error!(error=?err);
+                .unwrap_or_else(|error| {
+                    logger::error!(?error);
                     None
                 })
         } else {
@@ -4567,8 +4575,8 @@ where
         .transpose()
         .change_context(errors::StorageError::SerializationFailed)
         .attach_printable("Unable to convert data to a value")
-        .unwrap_or_else(|err| {
-            logger::error!(err=?err);
+        .unwrap_or_else(|error| {
+            logger::error!(?error);
             None
         })
         .map(Secret::<_, masking::WithType>::new)
@@ -4576,8 +4584,8 @@ where
         .await
         .change_context(errors::StorageError::EncryptionError)
         .attach_printable("Unable to encrypt data")
-        .unwrap_or_else(|err| {
-            logger::error!(err=?err);
+        .unwrap_or_else(|error| {
+            logger::error!(?error);
             None
         })
 }
diff --git a/crates/router/src/core/payments.rs b/crates/router/src/core/payments.rs
index 55edce1b85..ccca6eaed6 100644
--- a/crates/router/src/core/payments.rs
+++ b/crates/router/src/core/payments.rs
@@ -2172,9 +2172,9 @@ fn check_apple_pay_metadata(
                             )
                         })
                 })
-                .map_err(
-                    |error| logger::warn!(%error, "Failed to Parse Value to ApplepaySessionTokenData"),
-                );
+                .map_err(|error| {
+                    logger::warn!(?error, "Failed to Parse Value to ApplepaySessionTokenData")
+                });
 
             parsed_metadata.ok().map(|metadata| match metadata {
                 api_models::payments::ApplepaySessionTokenMetadata::ApplePayCombined(
@@ -2183,24 +2183,33 @@ fn check_apple_pay_metadata(
                     api_models::payments::ApplePayCombinedMetadata::Simplified { .. } => {
                         domain::ApplePayFlow::Simplified(payments_api::PaymentProcessingDetails {
                             payment_processing_certificate: state
-                            .conf
-                            .applepay_decrypt_keys
-                            .get_inner()
-                            .apple_pay_ppc
-                            .clone(),
+                                .conf
+                                .applepay_decrypt_keys
+                                .get_inner()
+                                .apple_pay_ppc
+                                .clone(),
                             payment_processing_certificate_key: state
-                            .conf
-                            .applepay_decrypt_keys
-                            .get_inner()
-                            .apple_pay_ppc_key
-                            .clone(),
-                         })
+                                .conf
+                                .applepay_decrypt_keys
+                                .get_inner()
+                                .apple_pay_ppc_key
+                                .clone(),
+                        })
                     }
-                    api_models::payments::ApplePayCombinedMetadata::Manual { payment_request_data: _, session_token_data } => {
-                        if let Some(manual_payment_processing_details_at) = session_token_data.payment_processing_details_at {
+                    api_models::payments::ApplePayCombinedMetadata::Manual {
+                        payment_request_data: _,
+                        session_token_data,
+                    } => {
+                        if let Some(manual_payment_processing_details_at) =
+                            session_token_data.payment_processing_details_at
+                        {
                             match manual_payment_processing_details_at {
-                                payments_api::PaymentProcessingDetailsAt::Hyperswitch(payment_processing_details) => domain::ApplePayFlow::Simplified(payment_processing_details),
-                                payments_api::PaymentProcessingDetailsAt::Connector => domain::ApplePayFlow::Manual,
+                                payments_api::PaymentProcessingDetailsAt::Hyperswitch(
+                                    payment_processing_details,
+                                ) => domain::ApplePayFlow::Simplified(payment_processing_details),
+                                payments_api::PaymentProcessingDetailsAt::Connector => {
+                                    domain::ApplePayFlow::Manual
+                                }
                             }
                         } else {
                             domain::ApplePayFlow::Manual
diff --git a/crates/router/src/core/payments/helpers.rs b/crates/router/src/core/payments/helpers.rs
index 2f332530df..8183a01fca 100644
--- a/crates/router/src/core/payments/helpers.rs
+++ b/crates/router/src/core/payments/helpers.rs
@@ -1922,7 +1922,7 @@ pub async fn retrieve_card_with_permanent_token(
             .map(|card_brand| enums::CardNetwork::from_str(&card_brand))
             .transpose()
             .map_err(|e| {
-                logger::error!("Failed to parse card network {}", e);
+                logger::error!("Failed to parse card network {e:?}");
             })
             .ok()
             .flatten(),
@@ -5035,8 +5035,8 @@ pub async fn config_skip_saving_wallet_at_connector(
                 .change_context(errors::ApiErrorResponse::InternalServerError)
                 .attach_printable("skip_save_wallet_at_connector config parsing failed")?,
         ),
-        Err(err) => {
-            logger::error!("{err}");
+        Err(error) => {
+            logger::error!(?error);
             None
         }
     })
diff --git a/crates/router/src/core/payments/retry.rs b/crates/router/src/core/payments/retry.rs
index ef8e0c01fe..6160ffacb0 100644
--- a/crates/router/src/core/payments/retry.rs
+++ b/crates/router/src/core/payments/retry.rs
@@ -540,8 +540,8 @@ pub async fn config_should_call_gsm(db: &dyn StorageInterface, merchant_id: &Str
         .await;
     match config {
         Ok(conf) => conf.config == "true",
-        Err(err) => {
-            logger::error!("{err}");
+        Err(error) => {
+            logger::error!(?error);
             false
         }
     }
diff --git a/crates/router/src/core/payments/transformers.rs b/crates/router/src/core/payments/transformers.rs
index d5f391ba15..f9d8860806 100644
--- a/crates/router/src/core/payments/transformers.rs
+++ b/crates/router/src/core/payments/transformers.rs
@@ -1016,7 +1016,7 @@ impl ForeignFrom<(storage::PaymentIntent, storage::PaymentAttempt)> for api::Pay
                 match data.parse_value("PaymentMethodDataResponseWithBilling") {
                     Ok(parsed_data) => Some(parsed_data),
                     Err(e) => {
-                        router_env::logger::error!("Failed to parse 'PaymentMethodDataResponseWithBilling' from payment method data. Error: {}", e);
+                        router_env::logger::error!("Failed to parse 'PaymentMethodDataResponseWithBilling' from payment method data. Error: {e:?}");
                         None
                     }
                 }
diff --git a/crates/router/src/core/payouts/retry.rs b/crates/router/src/core/payouts/retry.rs
index d552298498..fa61ab8a22 100644
--- a/crates/router/src/core/payouts/retry.rs
+++ b/crates/router/src/core/payouts/retry.rs
@@ -334,8 +334,8 @@ pub async fn config_should_call_gsm_payout(
         .await;
     match config {
         Ok(conf) => conf.config == "true",
-        Err(err) => {
-            logger::error!("{err}");
+        Err(error) => {
+            logger::error!(?error);
             false
         }
     }
diff --git a/crates/router/src/core/pm_auth.rs b/crates/router/src/core/pm_auth.rs
index d3393b5b1f..b3d228ced6 100644
--- a/crates/router/src/core/pm_auth.rs
+++ b/crates/router/src/core/pm_auth.rs
@@ -338,8 +338,8 @@ async fn store_bank_details_in_payment_methods(
                     .attach_printable("Failed to deserialize Payment Method Auth config")
             })
             .transpose()
-            .unwrap_or_else(|err| {
-                logger::error!(error=?err);
+            .unwrap_or_else(|error| {
+                logger::error!(?error);
                 None
             })
             .and_then(|pmd| match pmd {
diff --git a/crates/router/src/core/refunds.rs b/crates/router/src/core/refunds.rs
index 4c748ce96f..cf45f07729 100644
--- a/crates/router/src/core/refunds.rs
+++ b/crates/router/src/core/refunds.rs
@@ -1446,7 +1446,7 @@ pub async fn get_refund_sync_process_schedule_time(
     let mapping = match redis_mapping {
         Ok(x) => x,
         Err(err) => {
-            logger::error!("Error: while getting connector mapping: {}", err);
+            logger::error!("Error: while getting connector mapping: {err:?}");
             process_data::ConnectorPTMapping::default()
         }
     };
diff --git a/crates/router/src/core/user.rs b/crates/router/src/core/user.rs
index bbc0336abc..461ac85536 100644
--- a/crates/router/src/core/user.rs
+++ b/crates/router/src/core/user.rs
@@ -387,7 +387,7 @@ pub async fn change_password(
 
     let _ = auth::blacklist::insert_user_in_blacklist(&state, user.get_user_id())
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     #[cfg(not(feature = "email"))]
     {
@@ -399,7 +399,7 @@ pub async fn change_password(
                 diesel_models::enums::DashboardMetadata::IsChangePasswordRequired,
             )
             .await
-            .map_err(|e| logger::error!("Error while deleting dashboard metadata {}", e))
+            .map_err(|e| logger::error!("Error while deleting dashboard metadata {e:?}"))
             .ok();
     }
 
@@ -480,7 +480,7 @@ pub async fn rotate_password(
 
     let _ = auth::blacklist::insert_user_in_blacklist(&state, &user.user_id)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     auth::cookies::remove_cookie_response()
 }
@@ -535,15 +535,15 @@ pub async fn reset_password_token_only_flow(
                 storage_user::UserUpdate::VerifyUser,
             )
             .await
-            .map_err(|e| logger::error!(?e));
+            .map_err(|error| logger::error!(?error));
     }
 
     let _ = auth::blacklist::insert_email_token_in_blacklist(&state, &token)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
     let _ = auth::blacklist::insert_user_in_blacklist(&state, &user.user_id)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     auth::cookies::remove_cookie_response()
 }
@@ -593,10 +593,10 @@ pub async fn reset_password(
 
     let _ = auth::blacklist::insert_email_token_in_blacklist(&state, &token)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
     let _ = auth::blacklist::insert_user_in_blacklist(&state, &user.user_id)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     auth::cookies::remove_cookie_response()
 }
@@ -998,7 +998,7 @@ pub async fn accept_invite_from_email(
 
     let _ = auth::blacklist::insert_email_token_in_blacklist(&state, &token)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     let user_from_db: domain::UserFromStorage = state
         .global_store
@@ -1076,12 +1076,12 @@ pub async fn accept_invite_from_email_token_only_flow(
                 storage_user::UserUpdate::VerifyUser,
             )
             .await
-            .map_err(|e| logger::error!(?e));
+            .map_err(|error| logger::error!(?error));
     }
 
     let _ = auth::blacklist::insert_email_token_in_blacklist(&state, &token)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     let current_flow = domain::CurrentFlow::new(
         user_token,
@@ -1490,7 +1490,7 @@ pub async fn verify_email(
 
     let _ = auth::blacklist::insert_email_token_in_blacklist(&state, &token)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     let response = signin_strategy.get_signin_response(&state).await?;
     let token = utils::user::get_token_from_signin_response(&response);
@@ -1536,7 +1536,7 @@ pub async fn verify_email_token_only_flow(
 
     let _ = auth::blacklist::insert_email_token_in_blacklist(&state, &token)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     let current_flow = domain::CurrentFlow::new(user_token, domain::SPTFlow::VerifyEmail.into())?;
     let next_flow = current_flow.next(user_from_db, &state).await?;
@@ -1868,14 +1868,14 @@ pub async fn update_totp(
 
     let _ = tfa_utils::delete_totp_secret_from_redis(&state, &user_token.user_id)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     // This is not the main task of this API, so we don't throw error if this fails.
     // Any following API which requires TOTP will throw error if TOTP is not set in redis
     // and FE will ask user to enter TOTP again
     let _ = tfa_utils::insert_totp_in_redis(&state, &user_token.user_id)
         .await
-        .map_err(|e| logger::error!(?e));
+        .map_err(|error| logger::error!(?error));
 
     Ok(ApplicationResponse::StatusOk)
 }
diff --git a/crates/router/src/core/user_role.rs b/crates/router/src/core/user_role.rs
index 9e7f676c09..429907a73a 100644
--- a/crates/router/src/core/user_role.rs
+++ b/crates/router/src/core/user_role.rs
@@ -186,7 +186,7 @@ pub async fn accept_invitation(
             )
             .await
             .map_err(|e| {
-                logger::error!("Error while accepting invitation {}", e);
+                logger::error!("Error while accepting invitation {e:?}");
             })
             .ok()
     }))
@@ -216,7 +216,7 @@ pub async fn merchant_select(
             )
             .await
             .map_err(|e| {
-                logger::error!("Error while accepting invitation {}", e);
+                logger::error!("Error while accepting invitation {e:?}");
             })
             .ok()
     }))
@@ -270,7 +270,7 @@ pub async fn merchant_select_token_only_flow(
             )
             .await
             .map_err(|e| {
-                logger::error!("Error while accepting invitation {}", e);
+                logger::error!("Error while accepting invitation {e:?}");
             })
             .ok()
     }))
diff --git a/crates/router/src/db/merchant_connector_account.rs b/crates/router/src/db/merchant_connector_account.rs
index a176db2654..412c652298 100644
--- a/crates/router/src/db/merchant_connector_account.rs
+++ b/crates/router/src/db/merchant_connector_account.rs
@@ -476,9 +476,9 @@ impl MerchantConnectorAccountInterface for Store {
                         // -> it is not possible to write a `From` impl to convert the `diesel::result::Error` to `error_stack::Report<StorageError>`
                         //    because of Rust's orphan rules
                         router_env::logger::error!(
-                        ?error,
-                        "DB transaction for updating multiple merchant connector account failed"
-                    );
+                            ?error,
+                            "DB transaction for updating multiple merchant connector account failed"
+                        );
                         errors::StorageError::DatabaseConnectionError
                     })?;
                 }
diff --git a/crates/router/src/lib.rs b/crates/router/src/lib.rs
index e07434f9bb..20ebd3658a 100644
--- a/crates/router/src/lib.rs
+++ b/crates/router/src/lib.rs
@@ -270,7 +270,7 @@ pub async fn receiver_for_error(rx: oneshot::Receiver<()>, mut server: impl Stop
             server.stop_server().await;
         }
         Err(err) => {
-            logger::error!("Channel receiver error{err}");
+            logger::error!("Channel receiver error: {err}");
         }
     }
 }
diff --git a/crates/router/src/routes/payments.rs b/crates/router/src/routes/payments.rs
index 84c7986dd8..008528ee2e 100644
--- a/crates/router/src/routes/payments.rs
+++ b/crates/router/src/routes/payments.rs
@@ -595,8 +595,11 @@ pub async fn payments_connector_session(
 
     let header_payload = match HeaderPayload::foreign_try_from(req.headers()) {
         Ok(headers) => headers,
-        Err(err) => {
-            logger::error!(?err, "Failed to get headers in payments_connector_session");
+        Err(error) => {
+            logger::error!(
+                ?error,
+                "Failed to get headers in payments_connector_session"
+            );
             HeaderPayload::default()
         }
     };
diff --git a/crates/router/src/routes/payments/helpers.rs b/crates/router/src/routes/payments/helpers.rs
index c881ec7790..7ff3f1d11a 100644
--- a/crates/router/src/routes/payments/helpers.rs
+++ b/crates/router/src/routes/payments/helpers.rs
@@ -46,8 +46,11 @@ pub fn populate_ip_into_browser_info(
             .as_ref()
             .map(|ip| ip.parse())
             .transpose()
-            .unwrap_or_else(|e| {
-                logger::error!(error=?e, message="failed to parse ip address which is extracted from the request");
+            .unwrap_or_else(|error| {
+                logger::error!(
+                    ?error,
+                    "failed to parse ip address which is extracted from the request"
+                );
                 None
             })
     });
diff --git a/crates/router/src/services/api.rs b/crates/router/src/services/api.rs
index d65def0c97..540c67c576 100644
--- a/crates/router/src/services/api.rs
+++ b/crates/router/src/services/api.rs
@@ -1192,8 +1192,8 @@ pub fn http_response_json_with_headers<T: body::MessageBody + 'static>(
         }
         let mut header_value = match HeaderValue::from_str(header_value.as_str()) {
             Ok(header_value) => header_value,
-            Err(e) => {
-                logger::error!(?e);
+            Err(error) => {
+                logger::error!(?error);
                 return http_server_error_json_response("Something Went Wrong");
             }
         };
diff --git a/crates/router/src/services/authentication.rs b/crates/router/src/services/authentication.rs
index accc773478..adc23935d9 100644
--- a/crates/router/src/services/authentication.rs
+++ b/crates/router/src/services/authentication.rs
@@ -790,10 +790,10 @@ where
 {
     let token = match get_cookie_from_header(headers).and_then(cookies::parse_cookie) {
         Ok(cookies) => cookies,
-        Err(e) => {
+        Err(error) => {
             let token = get_jwt_from_authorization_header(headers);
             if token.is_err() {
-                logger::error!(?e);
+                logger::error!(?error);
             }
             token?.to_owned()
         }
diff --git a/crates/router/src/services/authorization.rs b/crates/router/src/services/authorization.rs
index 768c57a36d..530f538cfd 100644
--- a/crates/router/src/services/authorization.rs
+++ b/crates/router/src/services/authorization.rs
@@ -31,7 +31,7 @@ where
 
     if let Ok(permissions) = get_permissions_from_cache(state, &token.role_id)
         .await
-        .map_err(|e| logger::error!("Failed to get permissions from cache {}", e))
+        .map_err(|e| logger::error!("Failed to get permissions from cache {e:?}"))
     {
         return Ok(permissions);
     }
@@ -45,7 +45,7 @@ where
 
     set_permissions_in_cache(state, &token.role_id, &permissions, cache_ttl)
         .await
-        .map_err(|e| logger::error!("Failed to set permissions in cache {}", e))
+        .map_err(|e| logger::error!("Failed to set permissions in cache {e:?}"))
         .ok();
     Ok(permissions)
 }
diff --git a/crates/router/src/utils/currency.rs b/crates/router/src/utils/currency.rs
index c16b46e518..dcfe0347d6 100644
--- a/crates/router/src/utils/currency.rs
+++ b/crates/router/src/utils/currency.rs
@@ -134,8 +134,8 @@ async fn waited_fetch_and_update_caches(
                 return Ok(rates.clone());
             }
             Ok(None) => continue,
-            Err(e) => {
-                logger::error!(?e);
+            Err(error) => {
+                logger::error!(?error);
                 continue;
             }
         }
@@ -208,8 +208,8 @@ async fn handler_local_no_data(
             // No data in local as well as redis
             Ok(successive_fetch_and_save_forex(state, None).await?)
         }
-        Err(err) => {
-            logger::error!(?err);
+        Err(error) => {
+            logger::error!(?error);
             Ok(successive_fetch_and_save_forex(state, None).await?)
         }
     }
@@ -227,22 +227,22 @@ async fn successive_fetch_and_save_forex(
             let api_rates = fetch_forex_rates(state).await;
             match api_rates {
                 Ok(rates) => successive_save_data_to_redis_local(state, rates).await,
-                Err(err) => {
+                Err(error) => {
                     // API not able to fetch data call secondary service
-                    logger::error!(?err);
+                    logger::error!(?error);
                     let secondary_api_rates = fallback_fetch_forex_rates(state).await;
                     match secondary_api_rates {
                         Ok(rates) => Ok(successive_save_data_to_redis_local(state, rates).await?),
-                        Err(err) => stale_redis_data.ok_or({
-                            logger::error!(?err);
+                        Err(error) => stale_redis_data.ok_or({
+                            logger::error!(?error);
                             ForexCacheError::ApiUnresponsive.into()
                         }),
                     }
                 }
             }
         }
-        Err(e) => stale_redis_data.ok_or({
-            logger::error!(?e);
+        Err(error) => stale_redis_data.ok_or({
+            logger::error!(?error);
             ForexCacheError::ApiUnresponsive.into()
         }),
     }
@@ -259,8 +259,8 @@ async fn successive_save_data_to_redis_local(
         .async_and_then(|_val| async { Ok(save_forex_to_local(forex.clone()).await) })
         .await
         .map_or_else(
-            |e| {
-                logger::error!(?e);
+            |error| {
+                logger::error!(?error);
                 forex.clone()
             },
             |_| forex.clone(),
@@ -307,9 +307,9 @@ async fn handler_local_expired(
                 }
             }
         }
-        Err(e) => {
+        Err(error) => {
             //  data  not present in redis waited fetch
-            logger::error!(?e);
+            logger::error!(?error);
             successive_fetch_and_save_forex(state, Some(local_rates)).await
         }
     }
diff --git a/crates/router/src/workflows/api_key_expiry.rs b/crates/router/src/workflows/api_key_expiry.rs
index 8d8f1aa6c8..dc39de8f93 100644
--- a/crates/router/src/workflows/api_key_expiry.rs
+++ b/crates/router/src/workflows/api_key_expiry.rs
@@ -69,15 +69,17 @@ impl ProcessTrackerWorkflow<SessionState> for ApiKeyExpiryWorkflow {
             .ok_or(errors::ProcessTrackerError::EApiErrorResponse)?;
 
         let email_contents = ApiKeyExpiryReminder {
-            recipient_email: UserEmail::from_pii_email(email_id).map_err(|err| {
-                logger::error!(%err,"Failed to convert recipient's email to UserEmail from pii::Email");
+            recipient_email: UserEmail::from_pii_email(email_id).map_err(|error| {
+                logger::error!(
+                    ?error,
+                    "Failed to convert recipient's email to UserEmail from pii::Email"
+                );
                 errors::ProcessTrackerError::EApiErrorResponse
             })?,
             subject: "API Key Expiry Notice",
             expires_in: *expires_in,
             api_key_name,
             prefix,
-
         };
 
         state
diff --git a/crates/scheduler/src/db/queue.rs b/crates/scheduler/src/db/queue.rs
index a463111ab3..748e1f489c 100644
--- a/crates/scheduler/src/db/queue.rs
+++ b/crates/scheduler/src/db/queue.rs
@@ -91,7 +91,7 @@ impl QueueInterface for Store {
 
                 #[allow(unused_must_use)]
                 Err(error) => {
-                    logger::error!(error=?error.current_context());
+                    logger::error!(?error);
                     conn.delete_key(lock_key).await;
                     false
                 }
@@ -101,7 +101,7 @@ impl QueueInterface for Store {
                 false
             }
             Err(error) => {
-                logger::error!(error=%error.current_context(), %tag, "Error while locking");
+                logger::error!(?error, %tag, "Error while locking");
                 false
             }
         })
@@ -112,7 +112,7 @@ impl QueueInterface for Store {
         Ok(match is_lock_released {
             Ok(_del_reply) => true,
             Err(error) => {
-                logger::error!(error=%error.current_context(), %tag, "Error while releasing lock");
+                logger::error!(?error, %tag, "Error while releasing lock");
                 false
             }
         })
diff --git a/crates/scheduler/src/errors.rs b/crates/scheduler/src/errors.rs
index 52ea03e0c4..1fb7599aed 100644
--- a/crates/scheduler/src/errors.rs
+++ b/crates/scheduler/src/errors.rs
@@ -101,7 +101,7 @@ impl<T: PTError + std::fmt::Debug + std::fmt::Display> From<error_stack::Report<
     for ProcessTrackerError
 {
     fn from(error: error_stack::Report<T>) -> Self {
-        logger::error!(error=%error.current_context());
+        logger::error!(?error);
         error.current_context().to_pt_error()
     }
 }
diff --git a/crates/scheduler/src/producer.rs b/crates/scheduler/src/producer.rs
index 6390bc6689..6f710f55a3 100644
--- a/crates/scheduler/src/producer.rs
+++ b/crates/scheduler/src/producer.rs
@@ -76,7 +76,7 @@ where
                             // Intentionally not propagating error to caller.
                             // Any errors that occur in the producer flow must be handled here only, as
                             // this is the topmost level function which is concerned with the producer flow.
-                            error!(%error);
+                            error!(?error);
                         }
                     }
                 }
diff --git a/crates/scheduler/src/utils.rs b/crates/scheduler/src/utils.rs
index f3253e0ad3..f4f3a7c1bb 100644
--- a/crates/scheduler/src/utils.rs
+++ b/crates/scheduler/src/utils.rs
@@ -34,7 +34,7 @@ where
         let result = update_status_and_append(state, flow, batch).await;
         match result {
             Ok(_) => (),
-            Err(error) => logger::error!(error=%error.current_context()),
+            Err(error) => logger::error!(?error),
         }
     }
     Ok(())
@@ -54,23 +54,25 @@ where
         .map(|process| process.id.to_owned())
         .collect();
     match flow {
-        SchedulerFlow::Producer => {
-                state
-                .process_tracker_update_process_status_by_ids(
-                    process_ids,
-                    storage::ProcessTrackerUpdate::StatusUpdate {
-                        status: ProcessTrackerStatus::Processing,
-                        business_status: None,
-                    },
-                )
-                .await.map_or_else(|error| {
-                    logger::error!(error=%error.current_context(),"Error while updating process status");
+        SchedulerFlow::Producer => state
+            .process_tracker_update_process_status_by_ids(
+                process_ids,
+                storage::ProcessTrackerUpdate::StatusUpdate {
+                    status: ProcessTrackerStatus::Processing,
+                    business_status: None,
+                },
+            )
+            .await
+            .map_or_else(
+                |error| {
+                    logger::error!(?error, "Error while updating process status");
                     Err(error.change_context(errors::ProcessTrackerError::ProcessUpdateFailed))
-                }, |count| {
+                },
+                |count| {
                     logger::debug!("Updated status of {count} processes");
                     Ok(())
-                })
-        }
+                },
+            ),
         SchedulerFlow::Cleaner => {
             let res = state
                 .reinitialize_limbo_processes(process_ids, common_utils::date_time::now())
@@ -81,15 +83,15 @@ where
                     Ok(())
                 }
                 Err(error) => {
-                    logger::error!(error=%error.current_context(),"Error while reinitializing processes");
+                    logger::error!(?error, "Error while reinitializing processes");
                     Err(error.change_context(errors::ProcessTrackerError::ProcessUpdateFailed))
                 }
             }
         }
         _ => {
-            let error_msg = format!("Unexpected scheduler flow {flow:?}");
-            logger::error!(error = %error_msg);
-            Err(report!(errors::ProcessTrackerError::UnexpectedFlow).attach_printable(error_msg))
+            let error = format!("Unexpected scheduler flow {flow:?}");
+            logger::error!(%error);
+            Err(report!(errors::ProcessTrackerError::UnexpectedFlow).attach_printable(error))
         }
     }?;
 
@@ -108,19 +110,27 @@ where
         Err(mut err) => {
             let update_res = state
                 .process_tracker_update_process_status_by_ids(
-                    pt_batch.trackers.iter().map(|process| process.id.clone()).collect(),
+                    pt_batch
+                        .trackers
+                        .iter()
+                        .map(|process| process.id.clone())
+                        .collect(),
                     storage::ProcessTrackerUpdate::StatusUpdate {
                         status: ProcessTrackerStatus::Processing,
                         business_status: None,
                     },
                 )
-                .await.map_or_else(|error| {
-                    logger::error!(error=%error.current_context(),"Error while updating process status");
-                    Err(error.change_context(errors::ProcessTrackerError::ProcessUpdateFailed))
-                }, |count| {
-                    logger::debug!("Updated status of {count} processes");
-                    Ok(())
-                });
+                .await
+                .map_or_else(
+                    |error| {
+                        logger::error!(?error, "Error while updating process status");
+                        Err(error.change_context(errors::ProcessTrackerError::ProcessUpdateFailed))
+                    },
+                    |count| {
+                        logger::debug!("Updated status of {count} processes");
+                        Ok(())
+                    },
+                );
 
             match update_res {
                 Ok(_) => (),
@@ -275,7 +285,7 @@ pub fn add_histogram_metrics(
     #[warn(clippy::option_map_unit_fn)]
     if let Some((schedule_time, runner)) = task.schedule_time.as_ref().zip(task.runner.as_ref()) {
         let pickup_schedule_delta = (*pickup_time - *schedule_time).as_seconds_f64();
-        logger::error!(%pickup_schedule_delta, "<- Time delta for scheduled tasks");
+        logger::error!("Time delta for scheduled tasks: {pickup_schedule_delta} seconds");
         let runner_name = runner.clone();
         metrics::CONSUMER_STATS.record(
             &metrics::CONTEXT,