feat(aggregator): add more context when register single signature fail

Author: Alenar

mithril-aggregator/src/http_server/routes/signatures_routes.rs

@@ -56,13 +56,14 @@ mod handlers {
             .get_signature_registration_total_received_since_startup()
             .increment(&[METRICS_HTTP_ORIGIN]);
 
+        let payload = message.clone();
         let signed_entity_type = message.signed_entity_type.clone();
         let signed_message = message.signed_message.clone();
 
         let mut single_signature = match FromRegisterSingleSignatureAdapter::try_adapt(message) {
             Ok(signature) => signature,
             Err(err) => {
-                warn!(logger,"register_signatures::payload decoding error"; "error" => ?err);
+                warn!(logger,"register_signatures::payload decoding error"; "full_payload" => #?payload,"error" => ?err);
 
                 return Ok(reply::bad_request(
                     "Could not decode signature payload".to_string(),
@@ -92,22 +93,22 @@ mod handlers {
         {
             Err(err) => match err.downcast_ref::<CertifierServiceError>() {
                 Some(CertifierServiceError::AlreadyCertified(signed_entity_type)) => {
-                    debug!(logger,"register_signatures::open_message_already_certified"; "signed_entity_type" => ?signed_entity_type);
+                    debug!(logger, "register_signatures::open_message_already_certified"; "signed_entity_type" => ?signed_entity_type, "party_id" => &single_signature.party_id);
                     Ok(reply::gone(
                         "already_certified".to_string(),
                         err.to_string(),
                     ))
                 }
                 Some(CertifierServiceError::Expired(signed_entity_type)) => {
-                    debug!(logger,"register_signatures::open_message_expired"; "signed_entity_type" => ?signed_entity_type);
+                    debug!(logger, "register_signatures::open_message_expired"; "signed_entity_type" => ?signed_entity_type, "party_id" => &single_signature.party_id);
                     Ok(reply::gone("expired".to_string(), err.to_string()))
                 }
                 Some(CertifierServiceError::NotFound(signed_entity_type)) => {
-                    debug!(logger,"register_signatures::not_found"; "signed_entity_type" => ?signed_entity_type);
+                    debug!(logger, "register_signatures::not_found"; "signed_entity_type" => ?signed_entity_type, "party_id" => &single_signature.party_id);
                     Ok(reply::empty(StatusCode::NOT_FOUND))
                 }
                 Some(_) | None => {
-                    warn!(logger,"register_signatures::error"; "error" => ?err);
+                    warn!(logger,"register_signatures::error"; "full_payload" => #?payload, "error" => ?err);
                     Ok(reply::server_error(err))
                 }
             },

mithril-aggregator/src/services/certifier/buffered_certifier.rs

@@ -427,6 +427,7 @@ mod tests {
                         .returning(|_, _| {
                             Err(CertifierServiceError::InvalidSingleSignature(
                                 OpenMessage::dummy().signed_entity_type,
+                                "party_1".to_string(),
                                 anyhow!("Invalid signature"),
                             )
                             .into())

mithril-aggregator/src/services/certifier/certifier_service.rs

@@ -108,22 +108,27 @@ impl CertifierService for MithrilCertifierService {
     ) -> StdResult<SignatureRegistrationStatus> {
         debug!(
             self.logger,
-            ">> register_single_signature(signed_entity_type: {signed_entity_type:?}, single_signatures: {signature:?}"
+            ">> register_single_signature(signed_entity_type: {signed_entity_type:?}, single_signature: {signature:?}"
         );
-        trace!(self.logger, ">> register_single_signature"; "complete_single_signatures" => #?signature);
+        trace!(self.logger, ">> register_single_signature"; "complete_single_signature" => #?signature);
 
         let open_message = self
             .get_open_message_record(signed_entity_type)
-            .await.with_context(|| format!("CertifierService can not get open message record for signed_entity_type: '{signed_entity_type}'"))?
+            .await
+            .with_context(|| format!("CertifierService can not get open message record for signed_entity_type: '{signed_entity_type}'"))?
             .ok_or_else(|| {
-                warn!(self.logger, "register_single_signature: OpenMessage not found for type {signed_entity_type:?}.");
+                warn!(
+                    self.logger, "register_single_signature: OpenMessage not found for type {signed_entity_type:?}";
+                    "party_id" => &signature.party_id
+                );
                 CertifierServiceError::NotFound(signed_entity_type.clone())
             })?;
 
         if open_message.is_certified {
             warn!(
                 self.logger,
-                "register_single_signature: open message {signed_entity_type:?} is already certified, cannot register single signature."
+                "register_single_signature: open message {signed_entity_type:?} is already certified, cannot register single signature.";
+                "party_id" => &signature.party_id
             );
 
             return Err(CertifierServiceError::AlreadyCertified(signed_entity_type.clone()).into());
@@ -132,7 +137,8 @@ impl CertifierService for MithrilCertifierService {
         if open_message.is_expired {
             warn!(
                 self.logger,
-                "register_single_signature: open message {signed_entity_type:?} has expired, cannot register single signature."
+                "register_single_signature: open message {signed_entity_type:?} has expired, cannot register single signature.";
+                "party_id" => &signature.party_id
             );
 
             return Err(CertifierServiceError::Expired(signed_entity_type.clone()).into());
@@ -142,13 +148,18 @@ impl CertifierService for MithrilCertifierService {
             .verify_single_signature(&open_message.protocol_message.to_message(), signature)
             .await
             .map_err(|err| {
-                CertifierServiceError::InvalidSingleSignature(signed_entity_type.clone(), err)
+                CertifierServiceError::InvalidSingleSignature(
+                    signed_entity_type.clone(),
+                    signature.party_id.clone(),
+                    err,
+                )
             })?;
 
         let single_signature = self
             .single_signature_repository
             .create_single_signature(signature, &open_message.clone().into())
-            .await.with_context(|| format!("Certifier can not create the single signature from single_signature: '{signature:?}', open_message: '{open_message:?}'"))?;
+            .await
+            .with_context(|| format!("Certifier can not create the single signature from single_signature: '{signature:?}', open_message: '{open_message:?}'"))?;
         info!(
             self.logger,
             "register_single_signature: created pool '{}' single signature for {signed_entity_type:?}.",
@@ -826,7 +837,7 @@ mod tests {
         if let Some(err) = error.downcast_ref::<CertifierServiceError>() {
             assert!(matches!(
                 err,
-                CertifierServiceError::AlreadyCertified(signed_entity) if signed_entity == &signed_entity_type
+                CertifierServiceError::AlreadyCertified(signed_entity, ..) if signed_entity == &signed_entity_type
             ),);
         } else {
             panic!("Unexpected error {error:?}");

mithril-aggregator/src/services/certifier/interface.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use thiserror::Error;
 
 use mithril_common::entities::{
-    Certificate, Epoch, ProtocolMessage, SignedEntityType, SignedEntityTypeDiscriminants,
+    Certificate, Epoch, PartyId, ProtocolMessage, SignedEntityType, SignedEntityTypeDiscriminants,
     SingleSignature,
 };
 use mithril_common::{StdError, StdResult};
@@ -27,8 +27,8 @@ pub enum CertifierServiceError {
     Expired(SignedEntityType),
 
     /// An invalid signature was provided.
-    #[error("Invalid single signature for {0:?}.")]
-    InvalidSingleSignature(SignedEntityType, #[source] StdError),
+    #[error("Invalid single signature for {0:?} from party '{1}'.")]
+    InvalidSingleSignature(SignedEntityType, PartyId, #[source] StdError),
 
     /// No parent certificate could be found, this certifier cannot create genesis certificates.
     #[error(