{session,tracing}: switch to the new deser framework for tracing info

Adjusts the Session::try_getting_tracing_info method to use the new
deserialization framework.

Co-authored-by: Wojciech Przytuła <[email protected]>

Author: piodul

scylla/src/tracing.rs

@@ -1,15 +1,14 @@
+use crate::frame::value::CqlTimestamp;
 use itertools::Itertools;
 use scylla_cql::frame::value::CqlTimeuuid;
+use scylla_macros::DeserializeRow;
 use std::collections::HashMap;
 use std::net::IpAddr;
 
-use crate::cql_to_rust::{FromRow, FromRowError};
-use crate::frame::response::result::Row;
-use crate::frame::value::CqlTimestamp;
-
 /// Tracing info retrieved from `system_traces.sessions`
 /// with all events from `system_traces.events`
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, DeserializeRow, Clone, PartialEq, Eq)]
+#[scylla(crate = "crate")]
 pub struct TracingInfo {
     pub client: Option<IpAddr>,
     pub command: Option<String>,
@@ -20,11 +19,13 @@ pub struct TracingInfo {
     /// started_at is a timestamp - time since unix epoch
     pub started_at: Option<CqlTimestamp>,
 
+    #[scylla(skip)]
     pub events: Vec<TracingEvent>,
 }
 
 /// A single event happening during a traced query
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, DeserializeRow, Clone, PartialEq, Eq)]
+#[scylla(crate = "crate")]
 pub struct TracingEvent {
     pub event_id: CqlTimeuuid,
     pub activity: Option<String>,
@@ -53,51 +54,3 @@ pub(crate) const TRACES_SESSION_QUERY_STR: &str =
 pub(crate) const TRACES_EVENTS_QUERY_STR: &str =
     "SELECT event_id, activity, source, source_elapsed, thread \
     FROM system_traces.events WHERE session_id = ?";
-
-// Converts a row received by performing TRACES_SESSION_QUERY_STR to TracingInfo
-impl FromRow for TracingInfo {
-    fn from_row(row: Row) -> Result<TracingInfo, FromRowError> {
-        let (client, command, coordinator, duration, parameters, request, started_at) =
-            <(
-                Option<IpAddr>,
-                Option<String>,
-                Option<IpAddr>,
-                Option<i32>,
-                Option<HashMap<String, String>>,
-                Option<String>,
-                Option<CqlTimestamp>,
-            )>::from_row(row)?;
-
-        Ok(TracingInfo {
-            client,
-            command,
-            coordinator,
-            duration,
-            parameters,
-            request,
-            started_at,
-            events: Vec::new(),
-        })
-    }
-}
-
-// Converts a row received by performing TRACES_SESSION_QUERY_STR to TracingInfo
-impl FromRow for TracingEvent {
-    fn from_row(row: Row) -> Result<TracingEvent, FromRowError> {
-        let (event_id, activity, source, source_elapsed, thread) = <(
-            CqlTimeuuid,
-            Option<String>,
-            Option<IpAddr>,
-            Option<i32>,
-            Option<String>,
-        )>::from_row(row)?;
-
-        Ok(TracingEvent {
-            event_id,
-            activity,
-            source,
-            source_elapsed,
-            thread,
-        })
-    }
-}

scylla/src/transport/errors.rs

@@ -13,7 +13,6 @@ use std::{
 };
 
 use scylla_cql::{
-    cql_to_rust::FromRowError,
     frame::{
         frame_errors::{
             CqlAuthChallengeParseError, CqlAuthSuccessParseError, CqlAuthenticateParseError,
@@ -25,14 +24,17 @@ use scylla_cql::{
         response::CqlResponseKind,
         value::SerializeValuesError,
     },
-    types::{deserialize::TypeCheckError, serialize::SerializationError},
+    types::{
+        deserialize::{DeserializationError, TypeCheckError},
+        serialize::SerializationError,
+    },
 };
 
 use thiserror::Error;
 
 use crate::{authentication::AuthError, frame::response};
 
-use super::{legacy_query_result::RowsExpectedError, query_result::SingleRowError};
+use super::query_result::SingleRowError;
 
 /// Error that occurred during query execution
 #[derive(Error, Debug, Clone)]
@@ -360,20 +362,28 @@ pub enum SchemaVersionFetchError {
 #[non_exhaustive]
 pub enum TracingProtocolError {
     /// Response to system_traces.session is not RESULT:Rows.
-    #[error("Response to system_traces.session is not RESULT:Rows: {0}")]
-    TracesSessionNotRows(RowsExpectedError),
+    #[error("Response to system_traces.session is not RESULT:Rows")]
+    TracesSessionNotRows,
 
     /// system_traces.session has invalid column type.
     #[error("system_traces.session has invalid column type: {0}")]
-    TracesSessionInvalidColumnType(FromRowError),
+    TracesSessionInvalidColumnType(TypeCheckError),
+
+    /// Response to system_traces.session failed to deserialize.
+    #[error("Response to system_traces.session failed to deserialize: {0}")]
+    TracesSessionDeserializationFailed(DeserializationError),
 
     /// Response to system_traces.events is not RESULT:Rows.
-    #[error("Response to system_traces.events is not RESULT:Rows: {0}")]
-    TracesEventsNotRows(RowsExpectedError),
+    #[error("Response to system_traces.events is not RESULT:Rows")]
+    TracesEventsNotRows,
 
     /// system_traces.events has invalid column type.
     #[error("system_traces.events has invalid column type: {0}")]
-    TracesEventsInvalidColumnType(FromRowError),
+    TracesEventsInvalidColumnType(TypeCheckError),
+
+    /// Response to system_traces.events failed to deserialize.
+    #[error("Response to system_traces.events failed to deserialize: {0}")]
+    TracesEventsDeserializationFailed(DeserializationError),
 
     /// All tracing queries returned an empty result.
     #[error(

scylla/src/transport/session.rs

@@ -46,19 +46,20 @@ use super::connection::SslConfig;
 use super::errors::TracingProtocolError;
 use super::execution_profile::{ExecutionProfile, ExecutionProfileHandle, ExecutionProfileInner};
 use super::iterator::QueryPager;
-use super::legacy_query_result::MaybeFirstRowTypedError;
 #[cfg(feature = "cloud")]
 use super::node::CloudEndpoint;
 use super::node::{InternalKnownNode, KnownNode};
 use super::partitioner::PartitionerName;
+use super::query_result::MaybeFirstRowError;
+use super::query_result::RowsError;
 use super::topology::UntranslatedPeer;
 use super::{NodeRef, SelfIdentity};
 use crate::frame::response::result;
 use crate::prepared_statement::PreparedStatement;
 use crate::query::Query;
 use crate::routing::{Shard, Token};
 use crate::statement::{Consistency, PageSize, PagingState, PagingStateResponse};
-use crate::tracing::{TracingEvent, TracingInfo};
+use crate::tracing::TracingInfo;
 use crate::transport::cluster::{Cluster, ClusterData, ClusterNeatDebug};
 use crate::transport::connection::{Connection, ConnectionConfig, VerifiedKeyspaceName};
 use crate::transport::connection_pool::PoolConfig;
@@ -1790,15 +1791,18 @@ where
 
         // Get tracing info
         let maybe_tracing_info: Option<TracingInfo> = traces_session_res
-            .into_legacy_result()?
-            .maybe_first_row_typed()
+            .into_rows_result()?
+            .ok_or(ProtocolError::Tracing(
+                TracingProtocolError::TracesSessionNotRows,
+            ))?
+            .maybe_first_row()
             .map_err(|err| match err {
-                MaybeFirstRowTypedError::RowsExpected(e) => {
-                    ProtocolError::Tracing(TracingProtocolError::TracesSessionNotRows(e))
-                }
-                MaybeFirstRowTypedError::FromRowError(e) => {
+                MaybeFirstRowError::TypeCheckFailed(e) => {
                     ProtocolError::Tracing(TracingProtocolError::TracesSessionInvalidColumnType(e))
                 }
+                MaybeFirstRowError::DeserializationFailed(e) => ProtocolError::Tracing(
+                    TracingProtocolError::TracesSessionDeserializationFailed(e),
+                ),
             })?;
 
         let mut tracing_info = match maybe_tracing_info {
@@ -1807,20 +1811,23 @@ where
         };
 
         // Get tracing events
-        let tracing_event_rows = traces_events_res
-            .into_legacy_result()?
-            .rows_typed()
-            .map_err(|err| {
-                ProtocolError::Tracing(TracingProtocolError::TracesEventsNotRows(err))
-            })?;
-
-        for event in tracing_event_rows {
-            let tracing_event: TracingEvent = event.map_err(|err| {
+        let tracing_event_rows_result =
+            traces_events_res
+                .into_rows_result()?
+                .ok_or(ProtocolError::Tracing(
+                    TracingProtocolError::TracesEventsNotRows,
+                ))?;
+        let tracing_event_rows = tracing_event_rows_result.rows().map_err(|err| match err {
+            RowsError::TypeCheckFailed(err) => {
                 ProtocolError::Tracing(TracingProtocolError::TracesEventsInvalidColumnType(err))
-            })?;
+            }
+        })?;
 
-            tracing_info.events.push(tracing_event);
-        }
+        tracing_info.events = tracing_event_rows
+            .collect::<Result<_, _>>()
+            .map_err(|err| {
+                ProtocolError::Tracing(TracingProtocolError::TracesEventsDeserializationFailed(err))
+            })?;
 
         if tracing_info.events.is_empty() {
             return Ok(None);