feat: Introduce TransportError (#259)

Author: isSerge

src/services/blockchain/mod.rs

@@ -21,5 +21,5 @@ pub use error::BlockChainError;
 pub use pool::{ClientPool, ClientPoolTrait};
 pub use transports::{
 	BlockchainTransport, EVMTransportClient, EndpointManager, HttpTransportClient,
-	RotatingTransport, StellarTransportClient, TransientErrorRetryStrategy,
+	RotatingTransport, StellarTransportClient, TransientErrorRetryStrategy, TransportError,
 };

src/services/blockchain/transports/endpoint_manager.rs

@@ -9,7 +9,9 @@ use serde_json::Value;
 use std::sync::Arc;
 use tokio::sync::RwLock;
 
-use crate::services::blockchain::transports::{RotatingTransport, ROTATE_ON_ERROR_CODES};
+use crate::services::blockchain::transports::{
+	RotatingTransport, TransportError, ROTATE_ON_ERROR_CODES,
+};
 
 /// Manages the rotation of blockchain RPC endpoints
 ///
@@ -185,7 +187,7 @@ impl EndpointManager {
 	/// * `params` - The parameters for the RPC method call as a JSON Value
 	///
 	/// # Returns
-	/// * `Result<Value, anyhow::Error>` - The JSON response from the RPC endpoint or an error
+	/// * `Result<Value, TransportError>` - The JSON response from the RPC endpoint or an error
 	///
 	/// # Behavior
 	/// - Automatically rotates to fallback URLs if the request fails with specific status codes
@@ -200,31 +202,51 @@ impl EndpointManager {
 		transport: &T,
 		method: &str,
 		params: Option<P>,
-	) -> Result<Value, anyhow::Error> {
+	) -> Result<Value, TransportError> {
 		loop {
 			let current_url = self.active_url.read().await.clone();
 			let request_body = transport.customize_request(method, params.clone()).await;
 
-			let response = match self
+			let response_result = self
 				.client
 				.post(current_url.as_str())
 				.header("Content-Type", "application/json")
-				.body(
-					serde_json::to_string(&request_body)
-						.map_err(|e| anyhow::anyhow!("Failed to parse request: {}", e))?,
-				)
+				.body(serde_json::to_string(&request_body).map_err(|e| {
+					TransportError::request_serialization(
+						"Failed to serialize request JSON",
+						Some(Box::new(e)),
+						None,
+					)
+				})?)
 				.send()
-				.await
-			{
+				.await;
+
+			let response = match response_result {
 				Ok(resp) => resp,
-				Err(e) => {
-					tracing::warn!("Network error while sending request: {}", e);
+				Err(network_error) => {
+					tracing::warn!("Network error while sending request: {}", network_error);
 					// Try rotation for network errors without status check
-					if self.should_attempt_rotation(transport, false, None).await? {
-						continue;
+					let should_rotate = self.should_attempt_rotation(transport, false, None).await;
+
+					match should_rotate {
+						Ok(true) => continue,
+						Ok(false) => {
+							return Err(TransportError::network(
+								"Failed to send request due to network error",
+								Some(network_error.into()),
+								None,
+							))
+						}
+						Err(rotation_error) => {
+							let msg = "Failed to rotate URL after network error".to_string();
+							Err(TransportError::url_rotation(
+								msg,
+								Some(rotation_error.into()),
+								None,
+							))
+						}
 					}
-					return Err(anyhow::anyhow!("Failed to send request: {}", e));
-				}
+				}?,
 			};
 
 			let status = response.status();
@@ -233,19 +255,35 @@ impl EndpointManager {
 				tracing::warn!("Request failed with status {}: {}", status, error_body);
 
 				// Try rotation with status code check
-				if self
+				let should_rotate = self
 					.should_attempt_rotation(transport, true, Some(status.as_u16()))
-					.await?
-				{
-					continue;
+					.await;
+
+				match should_rotate {
+					Ok(true) => continue,
+					Ok(false) => {
+						return Err(TransportError::http(
+							status,
+							current_url,
+							error_body.clone(),
+							None,
+							None,
+						));
+					}
+					Err(e) => {
+						let msg = "Failed to rotate URL after HTTP error".to_string();
+						return Err(TransportError::url_rotation(msg, Some(e.into()), None));
+					}
 				}
-				return Err(anyhow::anyhow!("HTTP error {}: {}", status, error_body));
 			}
 
-			return response
-				.json()
-				.await
-				.map_err(|e| anyhow::anyhow!("Failed to parse response: {}", e));
+			return response.json().await.map_err(|e| {
+				TransportError::response_parse(
+					"Failed to parse JSON response",
+					Some(Box::new(e)),
+					None,
+				)
+			});
 		}
 	}
 }

src/services/blockchain/transports/error.rs

@@ -0,0 +1,254 @@
+//! Error types for blockchain transport services
+//!
+//! Provides error handling for network communication, JSON parsing, request serialization and URL rotation.
+
+use crate::utils::logging::error::{ErrorContext, TraceableError};
+use std::collections::HashMap;
+use thiserror::Error;
+
+#[derive(Debug, Error)]
+pub enum TransportError {
+	/// HTTP error
+	#[error("HTTP error: status {status_code} for URL {url}")]
+	Http {
+		status_code: reqwest::StatusCode,
+		url: String,
+		body: String,
+		context: ErrorContext,
+	},
+
+	/// Network error
+	#[error("Network error: {0}")]
+	Network(ErrorContext),
+
+	/// JSON parsing error
+	#[error("Failed to parse JSON response: {0}")]
+	ResponseParse(ErrorContext),
+
+	/// Request body serialization error
+	#[error("Failed to serialize request JSON: {0}")]
+	RequestSerialization(ErrorContext),
+
+	/// URL rotation error
+	#[error("URL rotation failed: {0}")]
+	UrlRotation(ErrorContext),
+}
+
+impl TransportError {
+	pub fn http(
+		status_code: reqwest::StatusCode,
+		url: String,
+		body: String,
+		source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+		metadata: Option<HashMap<String, String>>,
+	) -> Self {
+		let msg = format!("HTTP error: status {} for URL {}", status_code, url);
+
+		Self::Http {
+			status_code,
+			url,
+			body,
+			context: ErrorContext::new_with_log(msg, source, metadata),
+		}
+	}
+
+	pub fn network(
+		msg: impl Into<String>,
+		source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+		metadata: Option<HashMap<String, String>>,
+	) -> Self {
+		Self::Network(ErrorContext::new_with_log(msg, source, metadata))
+	}
+
+	pub fn response_parse(
+		msg: impl Into<String>,
+		source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+		metadata: Option<HashMap<String, String>>,
+	) -> Self {
+		Self::ResponseParse(ErrorContext::new_with_log(msg, source, metadata))
+	}
+
+	pub fn request_serialization(
+		msg: impl Into<String>,
+		source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+		metadata: Option<HashMap<String, String>>,
+	) -> Self {
+		Self::RequestSerialization(ErrorContext::new_with_log(msg, source, metadata))
+	}
+	pub fn url_rotation(
+		msg: impl Into<String>,
+		source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
+		metadata: Option<HashMap<String, String>>,
+	) -> Self {
+		Self::UrlRotation(ErrorContext::new_with_log(msg, source, metadata))
+	}
+}
+
+impl TraceableError for TransportError {
+	fn trace_id(&self) -> String {
+		match self {
+			Self::Http { context, .. } => context.trace_id.clone(),
+			Self::Network(ctx) => ctx.trace_id.clone(),
+			Self::ResponseParse(ctx) => ctx.trace_id.clone(),
+			Self::RequestSerialization(ctx) => ctx.trace_id.clone(),
+			Self::UrlRotation(ctx) => ctx.trace_id.clone(),
+		}
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use std::io::{Error as IoError, ErrorKind};
+
+	#[test]
+	fn test_http_error_formatting() {
+		let error = TransportError::http(
+			reqwest::StatusCode::NOT_FOUND,
+			"http://example.com".to_string(),
+			"Not Found".to_string(),
+			None,
+			None,
+		);
+		assert_eq!(
+			error.to_string(),
+			"HTTP error: status 404 Not Found for URL http://example.com"
+		);
+	}
+
+	#[test]
+	fn test_network_error_formatting() {
+		let error = TransportError::network("test error", None, None);
+		assert_eq!(error.to_string(), "Network error: test error");
+
+		let source_error = IoError::new(ErrorKind::NotFound, "test source");
+		let error = TransportError::network(
+			"test error",
+			Some(Box::new(source_error)),
+			Some(HashMap::from([("key1".to_string(), "value1".to_string())])),
+		);
+		assert_eq!(error.to_string(), "Network error: test error [key1=value1]");
+	}
+
+	#[test]
+	fn test_response_parse_error_formatting() {
+		let error = TransportError::response_parse("test error", None, None);
+		assert_eq!(
+			error.to_string(),
+			"Failed to parse JSON response: test error"
+		);
+
+		let source_error = IoError::new(ErrorKind::NotFound, "test source");
+		let error = TransportError::response_parse(
+			"test error",
+			Some(Box::new(source_error)),
+			Some(HashMap::from([("key1".to_string(), "value1".to_string())])),
+		);
+		assert_eq!(
+			error.to_string(),
+			"Failed to parse JSON response: test error [key1=value1]"
+		);
+	}
+
+	#[test]
+	fn test_request_serialization_error_formatting() {
+		let error = TransportError::request_serialization("test error", None, None);
+		assert_eq!(
+			error.to_string(),
+			"Failed to serialize request JSON: test error"
+		);
+
+		let source_error = IoError::new(ErrorKind::NotFound, "test source");
+		let error = TransportError::request_serialization(
+			"test error",
+			Some(Box::new(source_error)),
+			Some(HashMap::from([("key1".to_string(), "value1".to_string())])),
+		);
+		assert_eq!(
+			error.to_string(),
+			"Failed to serialize request JSON: test error [key1=value1]"
+		);
+	}
+
+	#[test]
+	fn test_url_rotation_error_formatting() {
+		let error = TransportError::url_rotation("test error", None, None);
+		assert_eq!(error.to_string(), "URL rotation failed: test error");
+
+		let source_error = IoError::new(ErrorKind::NotFound, "test source");
+		let error = TransportError::url_rotation(
+			"test error",
+			Some(Box::new(source_error)),
+			Some(HashMap::from([("key1".to_string(), "value1".to_string())])),
+		);
+		assert_eq!(
+			error.to_string(),
+			"URL rotation failed: test error [key1=value1]"
+		);
+	}
+
+	#[test]
+	fn test_error_source_chain() {
+		let io_error = std::io::Error::new(std::io::ErrorKind::Other, "while reading config");
+
+		let outer_error = TransportError::http(
+			reqwest::StatusCode::INTERNAL_SERVER_ERROR,
+			"http://example.com".to_string(),
+			"Internal Server Error".to_string(),
+			Some(Box::new(io_error)),
+			None,
+		);
+
+		// Just test the string representation instead of the source chain
+		assert!(outer_error.to_string().contains("Internal Server Error"));
+
+		// For TransportError::Http, we know the implementation details
+		if let TransportError::Http { context, .. } = &outer_error {
+			// Check that the context has the right message
+			assert_eq!(
+				context.message,
+				"HTTP error: status 500 Internal Server Error for URL http://example.com"
+			);
+
+			// Check that the context has the source error
+			assert!(context.source.is_some());
+
+			if let Some(src) = &context.source {
+				assert_eq!(src.to_string(), "while reading config");
+			}
+		} else {
+			panic!("Expected Http variant");
+		}
+	}
+
+	#[test]
+	fn test_trace_id_propagation() {
+		// Create an error context with a known trace ID
+		let error_context = ErrorContext::new("Inner error", None, None);
+		let original_trace_id = error_context.trace_id.clone();
+
+		// Wrap it in a TransportError
+		let transport_error = TransportError::Http {
+			status_code: reqwest::StatusCode::INTERNAL_SERVER_ERROR,
+			url: "http://example.com".to_string(),
+			body: "Internal Server Error".to_string(),
+			context: error_context,
+		};
+
+		// Verify the trace ID is preserved
+		assert_eq!(transport_error.trace_id(), original_trace_id);
+
+		// Test trace ID propagation through error chain
+		let source_error = IoError::new(ErrorKind::Other, "Source error");
+		let error_context = ErrorContext::new("Middle error", Some(Box::new(source_error)), None);
+		let original_trace_id = error_context.trace_id.clone();
+
+		let transport_error = TransportError::Http {
+			status_code: reqwest::StatusCode::INTERNAL_SERVER_ERROR,
+			url: "http://example.com".to_string(),
+			body: "Internal Server Error".to_string(),
+			context: error_context,
+		};
+		assert_eq!(transport_error.trace_id(), original_trace_id);
+	}
+}