From 31c5b502f5906361aa1f41aea6806999945b098f Mon Sep 17 00:00:00 2001 From: FroVolod Date: Wed, 14 Aug 2024 17:26:18 +0300 Subject: [PATCH 1/6] start --- src/common.rs | 121 ++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 92 insertions(+), 29 deletions(-) diff --git a/src/common.rs b/src/common.rs index 71e10e9b..52efdd8d 100644 --- a/src/common.rs +++ b/src/common.rs @@ -268,6 +268,7 @@ pub fn verify_account_access_key( } } +#[tracing::instrument(name = "Checking the existence of the account ...", skip_all)] pub fn is_account_exist( networks: &linked_hash_map::LinkedHashMap, account_id: near_primitives::types::AccountId, @@ -326,7 +327,7 @@ pub fn ask_if_different_account_id_wanted() -> color_eyre::eyre::Result { Ok(select_choose_input == ConfirmOptions::Yes) } -#[tracing::instrument(name = "Getting the account state ...", skip_all)] +#[tracing::instrument(name = "Getting account status information for", skip_all)] pub async fn get_account_state( network_config: &crate::config::NetworkConfig, account_id: &near_primitives::types::AccountId, @@ -336,6 +337,12 @@ pub async fn get_account_state( near_jsonrpc_client::errors::JsonRpcError, > { loop { + tracing::Span::current().pb_set_message(&format!( + "<{account_id}> on network <{}> ...", + network_config.network_name + )); + tracing::info!(target: "near_teach_me", "<{account_id}> on network <{}> ...", network_config.network_name); + let query_view_method_response = view_account( format!("{}", network_config.rpc_url), &network_config.json_rpc_client(), @@ -403,14 +410,46 @@ async fn view_account( near_jsonrpc_client::errors::JsonRpcError, > { tracing::Span::current().pb_set_message(&instrument_message); - json_rpc_client - .call(near_jsonrpc_client::methods::query::RpcQueryRequest { - block_reference, - request: near_primitives::views::QueryRequest::ViewAccount { - account_id: account_id.clone(), - }, - }) - .await + + let query_view_method_request = near_jsonrpc_client::methods::query::RpcQueryRequest { + block_reference, + request: near_primitives::views::QueryRequest::ViewAccount { + account_id: account_id.clone(), + }, + }; + let request_payload = request_payload(&query_view_method_request)?; + + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "I am making HTTP call to NEAR JSON RPC to query information about `{}` account, learn more https://docs.near.org/api/rpc/contracts#view-account", + account_id + ); + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "HTTP POST {}", + json_rpc_client.server_addr() + ); + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON Body:\n{}", + indent_payload(&format!("{:#}", request_payload)) + ); + + let query_view_method_response = json_rpc_client.call(query_view_method_request).await; + + let response_payload = response_payload(&query_view_method_response)?; + + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Response:\n{}", + indent_payload(&format!("{:#}", response_payload)) + ); + + query_view_method_response } fn need_check_account(message: String) -> bool { @@ -2203,8 +2242,12 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { indent_payload(&format!("{:#}", request_payload)) ); - let query_view_method_response: near_jsonrpc_client::methods::query::RpcQueryResponse = - self.blocking_call(query_view_method_request)?; + let query_view_method_response: Result< + near_jsonrpc_client::methods::query::RpcQueryResponse, + near_jsonrpc_client::errors::JsonRpcError< + near_jsonrpc_client::methods::query::RpcQueryError, + >, + > = self.blocking_call(query_view_method_request); let response_payload = response_payload(&query_view_method_response)?; @@ -2215,7 +2258,7 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { indent_payload(&format!("{:#}", response_payload)) ); - Ok(query_view_method_response) + query_view_method_response } #[tracing::instrument(name = "Getting a list of", skip_all)] @@ -2259,7 +2302,7 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { indent_payload(&format!("{:#}", request_payload)) ); - let query_view_method_response = self.blocking_call(query_view_method_request)?; + let query_view_method_response = self.blocking_call(query_view_method_request); let response_payload = response_payload(&query_view_method_response)?; @@ -2270,7 +2313,7 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { indent_payload(&format!("{:#}", response_payload)) ); - Ok(query_view_method_response) + query_view_method_response } #[tracing::instrument(name = "Getting information about", skip_all)] @@ -2314,7 +2357,7 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { indent_payload(&format!("{:#}", request_payload)) ); - let query_view_method_response = self.blocking_call(query_view_method_request)?; + let query_view_method_response = self.blocking_call(query_view_method_request); let response_payload = response_payload(&query_view_method_response)?; @@ -2325,11 +2368,11 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { indent_payload(&format!("{:#}", response_payload)) ); - Ok(query_view_method_response) + query_view_method_response } } -fn request_payload( +pub fn request_payload( query_view_method_request: &near_jsonrpc_client::methods::query::RpcQueryRequest, ) -> Result< serde_json::Value, @@ -2344,24 +2387,44 @@ fn request_payload( }) } -fn response_payload( - query_view_method_response: &near_jsonrpc_client::methods::query::RpcQueryResponse, +pub fn response_payload( + query_view_method_response: &Result< + near_jsonrpc_client::methods::query::RpcQueryResponse, + near_jsonrpc_client::errors::JsonRpcError< + near_jsonrpc_client::methods::query::RpcQueryError, + >, + >, ) -> Result< serde_json::Value, near_jsonrpc_client::errors::JsonRpcError, > { - serde_json::to_value(query_view_method_response).map_err(|err| { - near_jsonrpc_client::errors::JsonRpcError::TransportError( - near_jsonrpc_client::errors::RpcTransportError::SendError( - near_jsonrpc_client::errors::JsonRpcTransportSendError::PayloadSerializeError( - err.into(), - ), - ), - ) - }) + match query_view_method_response { + Ok(query_view_method_response) => { + serde_json::to_value(query_view_method_response).map_err(|err| { + near_jsonrpc_client::errors::JsonRpcError::TransportError( + near_jsonrpc_client::errors::RpcTransportError::SendError( + near_jsonrpc_client::errors::JsonRpcTransportSendError::PayloadSerializeError( + err.into(), + ), + ), + ) + }) + } + Err(json_rpc_error) => { + serde_json::to_value(json_rpc_error.to_string()).map_err(|err| { + near_jsonrpc_client::errors::JsonRpcError::TransportError( + near_jsonrpc_client::errors::RpcTransportError::SendError( + near_jsonrpc_client::errors::JsonRpcTransportSendError::PayloadSerializeError( + err.into(), + ), + ), + ) + }) + } + } } -pub(crate) fn indent_payload(s: &str) -> String { +pub fn indent_payload(s: &str) -> String { use std::fmt::Write; let mut indented_string = String::new(); From fbc6038c9d5e1a4468d37a9ab8c493f40ca93b0f Mon Sep 17 00:00:00 2001 From: FroVolod Date: Thu, 15 Aug 2024 09:48:04 +0300 Subject: [PATCH 2/6] added error handler for blocking_call_view_function() --- src/common.rs | 64 ++++++++++++++++++++++++++++++++------------------- 1 file changed, 40 insertions(+), 24 deletions(-) diff --git a/src/common.rs b/src/common.rs index 52efdd8d..7738f035 100644 --- a/src/common.rs +++ b/src/common.rs @@ -2152,7 +2152,7 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { tracing::info!( target: "near_teach_me", parent: &tracing::Span::none(), - "I am making HTTP call to NEAR JSON RPC to call a read-only function {} on `{}` account, learn more https://docs.near.org/api/rpc/contracts#call-a-contract-function", + "I am making HTTP call to NEAR JSON RPC to call a read-only `{}` function on `{}` account, learn more https://docs.near.org/api/rpc/contracts#call-a-contract-function", method_name, account_id ); @@ -2169,30 +2169,46 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { indent_payload(&format!("{:#}", request_payload)) ); - let query_view_method_response = self - .blocking_call(query_view_method_request) - .wrap_err("Failed to make a view-function call")?; - - let call_result = query_view_method_response.call_result()?; + let query_view_method_response = match self.blocking_call(query_view_method_request) { + Ok(response) => response, + Err(err) => { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Response:\n{}", + indent_payload(&err.to_string()) + ); + color_eyre::eyre::bail!("Failed to make a view-function call.\n{err}") + } + }; - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON RPC Response:\n{}", - indent_payload(&format!( - "{{\n \"block_hash\": {}\n \"block_height\": {}\n \"logs\": {:?}\n \"result\": {:?}\n}}", - query_view_method_response.block_hash, - query_view_method_response.block_height, - call_result.logs, - call_result.result - )) - ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "Decoding the \"result\" array of bytes as UTF-8 string (tip: here is a Python snippet: `\"\".join([chr(c) for c in result])`):\n{}", - indent_payload(&String::from_utf8(call_result.result.clone()).unwrap_or_else(|_| "".to_owned())) - ); + if let Ok(call_result) = query_view_method_response.call_result() { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Response:\n{}", + indent_payload(&format!( + "{{\n \"block_hash\": {}\n \"block_height\": {}\n \"logs\": {:?}\n \"result\": {:?}\n}}", + query_view_method_response.block_hash, + query_view_method_response.block_height, + call_result.logs, + call_result.result + )) + ); + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "Decoding the \"result\" array of bytes as UTF-8 string (tip: here is a Python snippet: `\"\".join([chr(c) for c in result])`):\n{}", + indent_payload(&String::from_utf8(call_result.result.clone()).unwrap_or_else(|_| "".to_owned())) + ); + } else { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Response:\n{}", + indent_payload("Internal error: Received unexpected query kind in response to a view-function query call") + ); + } query_view_method_response.call_result() } From 1cbef2c6ffc27879796db411a828a22f8fba7621 Mon Sep 17 00:00:00 2001 From: Vlad Frolov Date: Thu, 15 Aug 2024 12:17:25 +0200 Subject: [PATCH 3/6] refactored to use inspect/inspect_err where applicable and move it to the blocking_call to cover all the methods at once --- src/common.rs | 323 ++++++++++++++++++-------------------------------- 1 file changed, 117 insertions(+), 206 deletions(-) diff --git a/src/common.rs b/src/common.rs index 7738f035..73bb582c 100644 --- a/src/common.rs +++ b/src/common.rs @@ -417,7 +417,7 @@ async fn view_account( account_id: account_id.clone(), }, }; - let request_payload = request_payload(&query_view_method_request)?; + // let request_payload = request_payload(&query_view_method_request)?; tracing::info!( target: "near_teach_me", @@ -431,23 +431,23 @@ async fn view_account( "HTTP POST {}", json_rpc_client.server_addr() ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON Body:\n{}", - indent_payload(&format!("{:#}", request_payload)) - ); + // tracing::info!( + // target: "near_teach_me", + // parent: &tracing::Span::none(), + // "JSON Body:\n{}", + // indent_payload(&format!("{:#}", request_payload)) + // ); let query_view_method_response = json_rpc_client.call(query_view_method_request).await; - let response_payload = response_payload(&query_view_method_response)?; + // let response_payload = response_payload(&query_view_method_response)?; - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON RPC Response:\n{}", - indent_payload(&format!("{:#}", response_payload)) - ); + // tracing::info!( + // target: "near_teach_me", + // parent: &tracing::Span::none(), + // "JSON RPC Response:\n{}", + // indent_payload(&format!("{:#}", response_payload)) + // ); query_view_method_response } @@ -2064,7 +2064,8 @@ pub trait JsonRpcClientExt { method: M, ) -> near_jsonrpc_client::MethodCallResult where - M: near_jsonrpc_client::methods::RpcMethod; + M: near_jsonrpc_client::methods::RpcMethod, + M::Error: serde::Serialize + std::fmt::Debug + std::fmt::Display; /// A helper function to make a view-funcation call using JSON encoding for the function /// arguments and function return value. @@ -2118,10 +2119,54 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { ) -> near_jsonrpc_client::MethodCallResult where M: near_jsonrpc_client::methods::RpcMethod, + M::Error: serde::Serialize + std::fmt::Debug + std::fmt::Display, { + if let Ok(request_payload) = near_jsonrpc_client::methods::to_json(&method) { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "HTTP POST {}", + self.server_addr() + ); + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON Request Body:\n{}", + indent_payload(&format!("{:#}", request_payload)) + ); + } + tokio::runtime::Runtime::new() .unwrap() .block_on(self.call(method)) + .inspect_err(|err| match err { + near_jsonrpc_client::errors::JsonRpcError::TransportError(transport_error) => { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Request failed due to connectivity issue:\n{}", + indent_payload(&format!("{:#?}", transport_error)) + ); + } + near_jsonrpc_client::errors::JsonRpcError::ServerError( + near_jsonrpc_client::errors::JsonRpcServerError::HandlerError(handler_error), + ) => { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Request returned a handling error:\n{}", + indent_payload(&serde_json::to_string_pretty(handler_error).unwrap_or_else(|_| handler_error.to_string())) + ); + } + near_jsonrpc_client::errors::JsonRpcError::ServerError(server_error) => { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Request returned a generic server error:\n{}", + indent_payload(&format!("{:#?}", server_error)) + ); + } + }) } /// A helper function to make a view-funcation call using JSON encoding for the function @@ -2130,87 +2175,68 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { fn blocking_call_view_function( &self, account_id: &near_primitives::types::AccountId, - method_name: &str, + function_name: &str, args: Vec, block_reference: near_primitives::types::BlockReference, ) -> Result { tracing::Span::current().pb_set_message(&format!( - "the '{method_name}' method of the <{account_id}> contract ..." + "a read-only function '{function_name}' of the <{account_id}> contract ..." )); - tracing::info!(target: "near_teach_me", "the '{method_name}' method of the <{account_id}> contract ..."); + tracing::info!(target: "near_teach_me", "a read-only function '{function_name}' of the <{account_id}> contract ..."); let query_view_method_request = near_jsonrpc_client::methods::query::RpcQueryRequest { block_reference, request: near_primitives::views::QueryRequest::CallFunction { account_id: account_id.clone(), - method_name: method_name.to_owned(), + method_name: function_name.to_owned(), args: near_primitives::types::FunctionArgs::from(args), }, }; - let request_payload = near_jsonrpc_client::methods::to_json(&query_view_method_request)?; tracing::info!( target: "near_teach_me", parent: &tracing::Span::none(), - "I am making HTTP call to NEAR JSON RPC to call a read-only `{}` function on `{}` account, learn more https://docs.near.org/api/rpc/contracts#call-a-contract-function", - method_name, + "I am making HTTP call to NEAR JSON RPC to call a read-only function `{}` on `{}` account, learn more https://docs.near.org/api/rpc/contracts#call-a-contract-function", + function_name, account_id ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "HTTP POST {}", - self.server_addr() - ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON Body:\n{}", - indent_payload(&format!("{:#}", request_payload)) - ); - let query_view_method_response = match self.blocking_call(query_view_method_request) { - Ok(response) => response, - Err(err) => { + let query_view_method_response = self + .blocking_call(query_view_method_request) + .wrap_err("Read-only function execution failed")?; + + query_view_method_response.call_result() + .inspect(|call_result| { tracing::info!( target: "near_teach_me", parent: &tracing::Span::none(), "JSON RPC Response:\n{}", - indent_payload(&err.to_string()) + indent_payload(&format!( + "{{\n \"block_hash\": {}\n \"block_height\": {}\n \"logs\": {:?}\n \"result\": {:?}\n}}", + query_view_method_response.block_hash, + query_view_method_response.block_height, + call_result.logs, + call_result.result + )) ); - color_eyre::eyre::bail!("Failed to make a view-function call.\n{err}") - } - }; - - if let Ok(call_result) = query_view_method_response.call_result() { - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON RPC Response:\n{}", - indent_payload(&format!( - "{{\n \"block_hash\": {}\n \"block_height\": {}\n \"logs\": {:?}\n \"result\": {:?}\n}}", - query_view_method_response.block_hash, - query_view_method_response.block_height, - call_result.logs, - call_result.result - )) - ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "Decoding the \"result\" array of bytes as UTF-8 string (tip: here is a Python snippet: `\"\".join([chr(c) for c in result])`):\n{}", - indent_payload(&String::from_utf8(call_result.result.clone()).unwrap_or_else(|_| "".to_owned())) - ); - } else { - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON RPC Response:\n{}", - indent_payload("Internal error: Received unexpected query kind in response to a view-function query call") - ); - } - - query_view_method_response.call_result() + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "Decoding the \"result\" array of bytes as UTF-8 string (tip: you can use this Python snippet to do it: `\"\".join([chr(c) for c in result])`):\n{}", + indent_payload( + &String::from_utf8(call_result.result.clone()) + .unwrap_or_else(|_| "".to_owned()) + ) + ); + }) + .inspect_err(|_| { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Response:\n{}", + indent_payload("Internal error: Received unexpected query kind in response to a view-function query call") + ); + }) } #[tracing::instrument(name = "Getting access key information:", skip_all)] @@ -2225,9 +2251,10 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { near_jsonrpc_primitives::types::query::RpcQueryError, >, > { - tracing::Span::current() - .pb_set_message(&format!("{public_key} on {account_id} account ...")); - tracing::info!(target: "near_teach_me", "{public_key} on {account_id} account ..."); + tracing::Span::current().pb_set_message(&format!( + "public key {public_key} on account <{account_id}>..." + )); + tracing::info!(target: "near_teach_me", "public key {public_key} on account <{account_id}>..."); let query_view_method_request = near_jsonrpc_client::methods::query::RpcQueryRequest { block_reference, @@ -2236,45 +2263,16 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { public_key: public_key.clone(), }, }; - let request_payload = request_payload(&query_view_method_request)?; tracing::info!( target: "near_teach_me", parent: &tracing::Span::none(), - "I am making HTTP call to NEAR JSON RPC to get an access key {} details on `{}` account, learn more https://docs.near.org/api/rpc/access-keys#view-access-key", + "I am making HTTP call to NEAR JSON RPC to get an access key details for public key {} on account <{}>, learn more https://docs.near.org/api/rpc/access-keys#view-access-key", public_key, account_id ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "HTTP POST {}", - self.server_addr() - ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON Body:\n{}", - indent_payload(&format!("{:#}", request_payload)) - ); - - let query_view_method_response: Result< - near_jsonrpc_client::methods::query::RpcQueryResponse, - near_jsonrpc_client::errors::JsonRpcError< - near_jsonrpc_client::methods::query::RpcQueryError, - >, - > = self.blocking_call(query_view_method_request); - let response_payload = response_payload(&query_view_method_response)?; - - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON RPC Response:\n{}", - indent_payload(&format!("{:#}", response_payload)) - ); - - query_view_method_response + self.blocking_call(query_view_method_request) } #[tracing::instrument(name = "Getting a list of", skip_all)] @@ -2288,8 +2286,9 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { near_jsonrpc_primitives::types::query::RpcQueryError, >, > { - tracing::Span::current().pb_set_message(&format!("{account_id} access keys ...")); - tracing::info!(target: "near_teach_me", "{account_id} access keys ..."); + tracing::Span::current() + .pb_set_message(&format!("access keys on account <{account_id}>...")); + tracing::info!(target: "near_teach_me", "access keys on account <{account_id}>..."); let query_view_method_request = near_jsonrpc_client::methods::query::RpcQueryRequest { block_reference, @@ -2297,39 +2296,15 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { account_id: account_id.clone(), }, }; - let request_payload = request_payload(&query_view_method_request)?; tracing::info!( target: "near_teach_me", parent: &tracing::Span::none(), - "I am making HTTP call to NEAR JSON RPC to get a list of keys for `{}` account, learn more https://docs.near.org/api/rpc/access-keys#view-access-key-list", + "I am making HTTP call to NEAR JSON RPC to get a list of keys for account <{}>, learn more https://docs.near.org/api/rpc/access-keys#view-access-key-list", account_id ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "HTTP POST {}", - self.server_addr() - ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON Body:\n{}", - indent_payload(&format!("{:#}", request_payload)) - ); - - let query_view_method_response = self.blocking_call(query_view_method_request); - - let response_payload = response_payload(&query_view_method_response)?; - - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON RPC Response:\n{}", - indent_payload(&format!("{:#}", response_payload)) - ); - query_view_method_response + self.blocking_call(query_view_method_request) } #[tracing::instrument(name = "Getting information about", skip_all)] @@ -2343,8 +2318,8 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { near_jsonrpc_primitives::types::query::RpcQueryError, >, > { - tracing::Span::current().pb_set_message(&format!("{account_id} ...")); - tracing::info!(target: "near_teach_me", "{account_id} ..."); + tracing::Span::current().pb_set_message(&format!("account <{account_id}>...")); + tracing::info!(target: "near_teach_me", "account <{account_id}>..."); let query_view_method_request = near_jsonrpc_client::methods::query::RpcQueryRequest { block_reference, @@ -2352,91 +2327,27 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { account_id: account_id.clone(), }, }; - let request_payload = request_payload(&query_view_method_request)?; tracing::info!( target: "near_teach_me", parent: &tracing::Span::none(), - "I am making HTTP call to NEAR JSON RPC to query information about `{}` account, learn more https://docs.near.org/api/rpc/contracts#view-account", + "I am making HTTP call to NEAR JSON RPC to query information about account <{}>, learn more https://docs.near.org/api/rpc/contracts#view-account", account_id ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "HTTP POST {}", - self.server_addr() - ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON Body:\n{}", - indent_payload(&format!("{:#}", request_payload)) - ); - let query_view_method_response = self.blocking_call(query_view_method_request); - - let response_payload = response_payload(&query_view_method_response)?; + self.blocking_call(query_view_method_request) + .inspect(teach_me_call_response) + } +} +fn teach_me_call_response(response: &impl serde::Serialize) { + if let Ok(response_payload) = serde_json::to_value(response) { tracing::info!( target: "near_teach_me", parent: &tracing::Span::none(), "JSON RPC Response:\n{}", indent_payload(&format!("{:#}", response_payload)) ); - - query_view_method_response - } -} - -pub fn request_payload( - query_view_method_request: &near_jsonrpc_client::methods::query::RpcQueryRequest, -) -> Result< - serde_json::Value, - near_jsonrpc_client::errors::JsonRpcError, -> { - near_jsonrpc_client::methods::to_json(query_view_method_request).map_err(|err| { - near_jsonrpc_client::errors::JsonRpcError::TransportError( - near_jsonrpc_client::errors::RpcTransportError::SendError( - near_jsonrpc_client::errors::JsonRpcTransportSendError::PayloadSerializeError(err), - ), - ) - }) -} - -pub fn response_payload( - query_view_method_response: &Result< - near_jsonrpc_client::methods::query::RpcQueryResponse, - near_jsonrpc_client::errors::JsonRpcError< - near_jsonrpc_client::methods::query::RpcQueryError, - >, - >, -) -> Result< - serde_json::Value, - near_jsonrpc_client::errors::JsonRpcError, -> { - match query_view_method_response { - Ok(query_view_method_response) => { - serde_json::to_value(query_view_method_response).map_err(|err| { - near_jsonrpc_client::errors::JsonRpcError::TransportError( - near_jsonrpc_client::errors::RpcTransportError::SendError( - near_jsonrpc_client::errors::JsonRpcTransportSendError::PayloadSerializeError( - err.into(), - ), - ), - ) - }) - } - Err(json_rpc_error) => { - serde_json::to_value(json_rpc_error.to_string()).map_err(|err| { - near_jsonrpc_client::errors::JsonRpcError::TransportError( - near_jsonrpc_client::errors::RpcTransportError::SendError( - near_jsonrpc_client::errors::JsonRpcTransportSendError::PayloadSerializeError( - err.into(), - ), - ), - ) - }) - } } } From efb99e1ded49d9f278d4d56d2faeb79252872dc2 Mon Sep 17 00:00:00 2001 From: Vlad Frolov Date: Thu, 15 Aug 2024 12:56:13 +0200 Subject: [PATCH 4/6] fixed todos --- src/common.rs | 70 +++++++++++++++++++++++++++++++++++---------------- 1 file changed, 48 insertions(+), 22 deletions(-) diff --git a/src/common.rs b/src/common.rs index 73bb582c..f29afb7a 100644 --- a/src/common.rs +++ b/src/common.rs @@ -417,7 +417,6 @@ async fn view_account( account_id: account_id.clone(), }, }; - // let request_payload = request_payload(&query_view_method_request)?; tracing::info!( target: "near_teach_me", @@ -425,29 +424,54 @@ async fn view_account( "I am making HTTP call to NEAR JSON RPC to query information about `{}` account, learn more https://docs.near.org/api/rpc/contracts#view-account", account_id ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "HTTP POST {}", - json_rpc_client.server_addr() - ); - // tracing::info!( - // target: "near_teach_me", - // parent: &tracing::Span::none(), - // "JSON Body:\n{}", - // indent_payload(&format!("{:#}", request_payload)) - // ); - - let query_view_method_response = json_rpc_client.call(query_view_method_request).await; - // let response_payload = response_payload(&query_view_method_response)?; + if let Ok(request_payload) = near_jsonrpc_client::methods::to_json(&query_view_method_request) { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "HTTP POST {}", + json_rpc_client.server_addr() + ); + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON Request Body:\n{}", + indent_payload(&format!("{:#}", request_payload)) + ); + } - // tracing::info!( - // target: "near_teach_me", - // parent: &tracing::Span::none(), - // "JSON RPC Response:\n{}", - // indent_payload(&format!("{:#}", response_payload)) - // ); + let query_view_method_response = json_rpc_client + .call(query_view_method_request) + .await + .inspect_err(|err| match err { + near_jsonrpc_client::errors::JsonRpcError::TransportError(transport_error) => { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Request failed due to connectivity issue:\n{}", + indent_payload(&format!("{:#?}", transport_error)) + ); + } + near_jsonrpc_client::errors::JsonRpcError::ServerError( + near_jsonrpc_client::errors::JsonRpcServerError::HandlerError(handler_error), + ) => { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Request returned a handling error:\n{}", + indent_payload(&serde_json::to_string_pretty(handler_error).unwrap_or_else(|_| handler_error.to_string())) + ); + } + near_jsonrpc_client::errors::JsonRpcError::ServerError(server_error) => { + tracing::info!( + target: "near_teach_me", + parent: &tracing::Span::none(), + "JSON RPC Request returned a generic server error:\n{}", + indent_payload(&format!("{:#?}", server_error)) + ); + } + }) + .inspect(teach_me_call_response); query_view_method_response } @@ -2273,6 +2297,7 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { ); self.blocking_call(query_view_method_request) + .inspect(teach_me_call_response) } #[tracing::instrument(name = "Getting a list of", skip_all)] @@ -2305,6 +2330,7 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { ); self.blocking_call(query_view_method_request) + .inspect(teach_me_call_response) } #[tracing::instrument(name = "Getting information about", skip_all)] From 34bac8a16a64ecfcbfff0f0e7e3570070a16b1c6 Mon Sep 17 00:00:00 2001 From: FroVolod Date: Mon, 26 Aug 2024 16:09:33 +0300 Subject: [PATCH 5/6] clippy --- src/common.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/common.rs b/src/common.rs index f29afb7a..c032b786 100644 --- a/src/common.rs +++ b/src/common.rs @@ -440,7 +440,7 @@ async fn view_account( ); } - let query_view_method_response = json_rpc_client + json_rpc_client .call(query_view_method_request) .await .inspect_err(|err| match err { @@ -471,9 +471,7 @@ async fn view_account( ); } }) - .inspect(teach_me_call_response); - - query_view_method_response + .inspect(teach_me_call_response) } fn need_check_account(message: String) -> bool { From c47df158f6677bfd489e7f3d61427ef7ef3172f4 Mon Sep 17 00:00:00 2001 From: FroVolod Date: Mon, 26 Aug 2024 16:17:58 +0300 Subject: [PATCH 6/6] updated sending_signed_transaction() --- src/common.rs | 2 +- src/transaction_signature_options/send/mod.rs | 28 ++++--------------- 2 files changed, 6 insertions(+), 24 deletions(-) diff --git a/src/common.rs b/src/common.rs index c032b786..527d9909 100644 --- a/src/common.rs +++ b/src/common.rs @@ -2364,7 +2364,7 @@ impl JsonRpcClientExt for near_jsonrpc_client::JsonRpcClient { } } -fn teach_me_call_response(response: &impl serde::Serialize) { +pub(crate) fn teach_me_call_response(response: &impl serde::Serialize) { if let Ok(response_payload) = serde_json::to_value(response) { tracing::info!( target: "near_teach_me", diff --git a/src/transaction_signature_options/send/mod.rs b/src/transaction_signature_options/send/mod.rs index da2686f3..52fb85d1 100644 --- a/src/transaction_signature_options/send/mod.rs +++ b/src/transaction_signature_options/send/mod.rs @@ -87,27 +87,17 @@ pub fn sending_signed_transaction( near_jsonrpc_client::methods::broadcast_tx_commit::RpcBroadcastTxCommitRequest { signed_transaction: signed_transaction.clone(), }; - let request_payload = near_jsonrpc_client::methods::to_json(&request)?; tracing::info!( target: "near_teach_me", parent: &tracing::Span::none(), "I am making HTTP call to NEAR JSON RPC to broadcast a transaction, learn more https://docs.near.org/api/rpc/transactions#send-tx" ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "HTTP POST {}", - network_config.rpc_url.as_str(), - ); - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON Body:\n{}", - crate::common::indent_payload(&format!("{:#}", request_payload)) - ); - let transaction_info_result = network_config.json_rpc_client().blocking_call(request); + let transaction_info_result = network_config + .json_rpc_client() + .blocking_call(request) + .inspect(crate::common::teach_me_call_response); match transaction_info_result { Ok(response) => { break response; @@ -130,15 +120,6 @@ pub fn sending_signed_transaction( }; }; - let response_payload = serde_json::to_value(&transaction_info)?; - - tracing::info!( - target: "near_teach_me", - parent: &tracing::Span::none(), - "JSON RPC Response:\n{}", - crate::common::indent_payload(&format!("{:#}", response_payload)) - ); - Ok(transaction_info) } @@ -148,6 +129,7 @@ pub fn sending_signed_transaction( )] pub fn sleep_after_error(additional_message_for_name: String) { tracing::Span::current().pb_set_message(&additional_message_for_name); + tracing::info!(target: "near_teach_me", "{}", &additional_message_for_name); std::thread::sleep(std::time::Duration::from_secs(5)); }