new logs

Signed-off-by: Shoham Elias <shohame@amazon.com>

Author: shohamazon

glide-core/redis-rs/redis/src/aio/multiplexed_connection.rs

@@ -193,6 +193,10 @@ where
             } => {
                 match result {
                     Ok(Value::ServerError(err)) if *is_transaction => {
+                        println!(
+                            "Transaction ServerError received: {}. This indicates an error occurred between MULTI and EXEC.",
+                            err
+                        );
                         // In transactions, `count` is always 1 because the final result is a single array (`offset + count = expected_response_count`).
                         // If we receive a `ServerError` here, it means the error occurred between `MULTI` and `EXEC`.
                         // After `EXEC`, the response is always a single array of results, so any error at this stage must have happened before `EXEC` was sent.
@@ -202,9 +206,11 @@ where
                         }
                     }
                     Ok(item) => {
+                        println!("Pipeline response received: {:?}", item);
                         buffer.push(item);
                     }
                     Err(err) => {
+                        println!("Pipeline error received: {:?}", err);
                         if first_err.is_none() {
                             *first_err = Some(err);
                         }

glide-core/redis-rs/redis/src/cluster_async/mod.rs

@@ -2647,6 +2647,12 @@ where
                 sub_pipeline,
                 pipeline_retry_strategy,
             } => {
+                println!(
+                    "try_request: Pipeline command received. Atomic: {}, Sub-pipeline: {}",
+                    pipeline.is_atomic(),
+                    sub_pipeline
+                );
+                println!("Pipeline commands:\n{:?}", pipeline);
                 if pipeline.is_atomic() || sub_pipeline {
                     // If the pipeline is atomic (i.e., a transaction) or if the pipeline is already splitted into sub-pipelines (i.e., the pipeline is already routed to a specific node), we can send it as is, with no need to split it into sub-pipelines.
                     Self::try_pipeline_request(

glide-core/redis-rs/redis/src/cluster_async/pipeline_routing.rs

@@ -584,6 +584,10 @@ fn process_pipeline_responses(
     for ((address, command_indices), response_result) in
         addresses_and_indices.into_iter().zip(responses)
     {
+        println!(
+            "Processing response from node: {} response {response_result:?}",
+            address
+        );
         let (server_error, retry_method) = match response_result {
             Ok(Ok(Response::Multiple(values))) => {
                 // Add each response to the pipeline_responses vector at the appropriate index
@@ -640,6 +644,10 @@ fn process_pipeline_responses(
             // If we received a redis error, we will convert it to a ServerError and append it to the relevant indices
             Ok(Err(err)) => {
                 let retry_method = err.retry_method();
+                println!(
+                    "Pipeline command received server error from node {}: {:?}, retry method: {:?}",
+                    address, err, retry_method
+                );
                 (err.into(), retry_method)
             }
             // If we received a receive (connection) error, we will create a ServerError and append it to the relevant indices.
@@ -724,6 +732,10 @@ fn update_retry_map(
         RetryMethod::RefreshSlotsAndRetry => {
             // TODO: Add support for refreshing slots and retrying in pipelines
             // https://github.com/valkey-io/valkey-glide/issues/5226
+            println!(
+                "Warning: RefreshSlotsAndRetry is not yet supported for pipelines. Skipping retry for command at index {}.",
+                index
+            );
         }
         RetryMethod::RetryImmediately
         | RetryMethod::WaitAndRetry