fixup! feat(advance-runner): log tainted session reason

offchain/advance-runner/src/server_manager/facade.rs

@@ -199,7 +199,7 @@ impl ServerManagerFacade {
             }
         });
 
-        self.handle_advance_state_error(response).await;
+        self.handle_advance_state_error(response).await?;
 
         tracing::trace!("waiting until the input is processed");
 
@@ -278,22 +278,25 @@ impl ServerManagerFacade {
     async fn handle_advance_state_error(
         &mut self,
         response: Result<grpc_interfaces::cartesi_machine::Void>,
-    ) {
-        // Capture server-manager error for advance-state request
-        // to try to get the reason for a possible tainted session error.
-        if response.is_err() {
-            match response.unwrap_err() {
+    ) -> Result<()> {
+        if response.is_ok() {
+            Ok(())
+        } else {
+            // Capture server-manager error for advance-state request
+            // to try to get the reason for a possible tainted session error.
+            let err = response.unwrap_err();
+
+            let err: ServerManagerError = match err {
                 ServerManagerError::MethodCallError {
-                    method: _,
-                    request_id: _,
+                    method,
+                    request_id,
                     source,
                 } => {
                     // Original error message to be reported by default.
                     let mut message = source.message().to_string();
                     // The server-manager signals with code Dataloss when the session has been previously tainted.
                     if source.code() == tonic::Code::DataLoss {
                         // Recover the tainted session reason from the session's status.
-                        // If not available, log the original error message.
                         let status_response = grpc_call!(
                             self,
                             get_session_status,
@@ -309,17 +312,34 @@ impl ServerManagerFacade {
                                     request_id: _,
                                     source,
                                 } => {
-                                    message = format!("Server manager session was tainted: {} ({})", source.code(), source.message());
+                                    tracing::error!(
+                                        "get-session-status error: {:?}",
+                                        source.message()
+                                    );
                                 }
                                 _ => {}
                             }
                         } else {
+                            let status_response = status_response.unwrap();
+                            let taint_status =
+                                status_response.taint_status.clone();
+                            if let Some(taint_status) = taint_status {
+                                message = format!("Server manager session was tainted: {} ({})",
+                                    taint_status.error_code,
+                                    taint_status.error_message);
+                            }
                         }
                     }
                     tracing::error!(message);
+                    ServerManagerError::MethodCallError {
+                        method,
+                        request_id,
+                        source: tonic::Status::new(source.code(), message),
+                    }
                 }
-                _ => {}
-            }
+                _ => err,
+            };
+            Err(err)
         }
     }
 
@@ -421,3 +441,15 @@ impl ServerManagerFacade {
         Err(ServerManagerError::PendingInputsExceededError {})
     }
 }
+
+#[tracing::instrument(level = "trace", skip_all)]
+fn get_advance_state_error_message(err: &ServerManagerError) -> Option<String> {
+    match err {
+        ServerManagerError::MethodCallError {
+            method: _,
+            request_id: _,
+            source,
+        } => Some(source.message().to_string()),
+        _ => None,
+    }
+}

offchain/advance-runner/tests/host_integration.rs

@@ -116,7 +116,7 @@ async fn advance_runner_fails_when_inputs_has_wrong_epoch() {
 
     tracing::info!("waiting for the advance_runner to exit with error");
     let err = state.advance_runner.wait_err().await;
-    assert!(format!("{:?}", err).contains("unknown epoch index"));
+    assert!(format!("{:?}", err).contains("incorrect active epoch index"));
 }
 
 #[test_log::test(tokio::test)]