errors: rename and extract TracingError

It was previously called `TracingProtocolError` and was contained in ExecutionError::ProtocolError.

Since we now have a big picture of errors hierarchy, it's much clearer that `TracingError` should
be a separate error type returned by tracing methods. ExecutionError should NOT depend on it.

This commit renamed TracingProtocolError to TracingError, and changes the return type
of Session::get_tracing_info(). New variant is introduced to `TracingError` - it contains
an `ExecutionError`, which makes sense since we try to execute queries to system tracing
tables.

Author: muzarski

scylla/src/client/session.rs

@@ -16,7 +16,7 @@ use crate::cluster::node::{InternalKnownNode, KnownNode, NodeRef};
 use crate::cluster::{Cluster, ClusterNeatDebug, ClusterState};
 use crate::errors::{
     BadQuery, ExecutionError, MetadataError, NewSessionError, ProtocolError, RequestAttemptError,
-    RequestError, TracingProtocolError, UseKeyspaceError,
+    RequestError, TracingError, UseKeyspaceError,
 };
 use crate::frame::response::result;
 #[cfg(feature = "ssl")]
@@ -1742,7 +1742,7 @@ where
     ///
     /// See [the book](https://rust-driver.docs.scylladb.com/stable/tracing/tracing.html)
     /// for more information about query tracing
-    pub async fn get_tracing_info(&self, tracing_id: &Uuid) -> Result<TracingInfo, ExecutionError> {
+    pub async fn get_tracing_info(&self, tracing_id: &Uuid) -> Result<TracingInfo, TracingError> {
         // tracing_info_fetch_attempts is NonZeroU32 so at least one attempt will be made
         for _ in 0..self.tracing_info_fetch_attempts.get() {
             let current_try: Option<TracingInfo> = self
@@ -1755,7 +1755,7 @@ where
             };
         }
 
-        Err(ProtocolError::Tracing(TracingProtocolError::EmptyResults).into())
+        Err(TracingError::EmptyResults)
     }
 
     /// Gets the name of the keyspace that is currently set, or `None` if no
@@ -1780,7 +1780,7 @@ where
         &self,
         tracing_id: &Uuid,
         consistency: Option<Consistency>,
-    ) -> Result<Option<TracingInfo>, ExecutionError> {
+    ) -> Result<Option<TracingInfo>, TracingError> {
         // Query system_traces.sessions for TracingInfo
         let mut traces_session_query =
             Query::new(crate::observability::tracing::TRACES_SESSION_QUERY_STR);
@@ -1801,17 +1801,15 @@ where
         // Get tracing info
         let maybe_tracing_info: Option<TracingInfo> = traces_session_res
             .into_rows_result()
-            .map_err(|err| {
-                ProtocolError::Tracing(TracingProtocolError::TracesSessionIntoRowsResultError(err))
-            })?
+            .map_err(TracingError::TracesSessionIntoRowsResultError)?
             .maybe_first_row()
             .map_err(|err| match err {
                 MaybeFirstRowError::TypeCheckFailed(e) => {
-                    ProtocolError::Tracing(TracingProtocolError::TracesSessionInvalidColumnType(e))
+                    TracingError::TracesSessionInvalidColumnType(e)
+                }
+                MaybeFirstRowError::DeserializationFailed(e) => {
+                    TracingError::TracesSessionDeserializationFailed(e)
                 }
-                MaybeFirstRowError::DeserializationFailed(e) => ProtocolError::Tracing(
-                    TracingProtocolError::TracesSessionDeserializationFailed(e),
-                ),
             })?;
 
         let mut tracing_info = match maybe_tracing_info {
@@ -1820,20 +1818,16 @@ where
         };
 
         // Get tracing events
-        let tracing_event_rows_result = traces_events_res.into_rows_result().map_err(|err| {
-            ProtocolError::Tracing(TracingProtocolError::TracesEventsIntoRowsResultError(err))
-        })?;
+        let tracing_event_rows_result = traces_events_res
+            .into_rows_result()
+            .map_err(TracingError::TracesEventsIntoRowsResultError)?;
         let tracing_event_rows = tracing_event_rows_result.rows().map_err(|err| match err {
-            RowsError::TypeCheckFailed(err) => {
-                ProtocolError::Tracing(TracingProtocolError::TracesEventsInvalidColumnType(err))
-            }
+            RowsError::TypeCheckFailed(err) => TracingError::TracesEventsInvalidColumnType(err),
         })?;
 
         tracing_info.events = tracing_event_rows
             .collect::<Result<_, _>>()
-            .map_err(|err| {
-                ProtocolError::Tracing(TracingProtocolError::TracesEventsDeserializationFailed(err))
-            })?;
+            .map_err(TracingError::TracesEventsDeserializationFailed)?;
 
         if tracing_info.events.is_empty() {
             return Ok(None);

scylla/src/errors.rs

@@ -217,10 +217,6 @@ pub enum ProtocolError {
     #[error("Unable extract a partition key based on prepared statement's metadata")]
     PartitionKeyExtraction,
 
-    /// A protocol error occurred during tracing info fetch.
-    #[error("Tracing info fetch protocol error: {0}")]
-    Tracing(#[from] TracingProtocolError),
-
     /// Driver tried to reprepare a statement in the batch, but the reprepared
     /// statement's id is not included in the batch.
     #[error("Reprepared statement's id does not exist in the batch.")]
@@ -267,10 +263,16 @@ pub enum SchemaVersionFetchError {
     SingleRowError(SingleRowError),
 }
 
-/// A protocol error that occurred during tracing info fetch.
+/// An error that occurred during tracing info fetch.
 #[derive(Error, Debug, Clone)]
 #[non_exhaustive]
-pub enum TracingProtocolError {
+pub enum TracingError {
+    /// Failed to execute query to either "system_traces.sessions" or "system_traces.events".
+    #[error(
+        "Failed to execute queries to \"system_traces.sessions\" or \"system_traces.events\" system tables: {0}"
+    )]
+    ExecutionError(#[from] ExecutionError),
+
     /// Failed to convert result of system_traces.session query to rows result.
     #[error("Failed to convert result of system_traces.session query to rows result")]
     TracesSessionIntoRowsResultError(IntoRowsResultError),