Simplify new cycle log for state machines

Author: Alenar

mithril-aggregator/src/runtime/state_machine.rs

@@ -1,7 +1,7 @@
 use super::{AggregatorRunnerTrait, RuntimeError};
 
 use mithril_common::entities::{Beacon, CertificatePending};
-use slog_scope::{debug, error, info, trace, warn};
+use slog_scope::{error, info, trace, warn};
 use std::fmt::Display;
 use std::sync::Arc;
 use tokio::time::{sleep, Duration};
@@ -32,9 +32,16 @@ pub enum AggregatorState {
 impl Display for AggregatorState {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            AggregatorState::Idle(state) => write!(f, "Idle - {:?}", state.current_beacon),
-            AggregatorState::Ready(state) => write!(f, "Ready - {:?}", state.current_beacon),
-            AggregatorState::Signing(state) => write!(f, "Signing - {:?}", state.current_beacon),
+            AggregatorState::Idle(state) => write!(
+                f,
+                "Idle - {}",
+                match &state.current_beacon {
+                    None => "No Beacon".to_string(),
+                    Some(b) => b.to_string(),
+                }
+            ),
+            AggregatorState::Ready(state) => write!(f, "Ready - {}", state.current_beacon),
+            AggregatorState::Signing(state) => write!(f, "Signing - {}", state.current_beacon),
         }
     }
 }
@@ -90,11 +97,11 @@ impl AggregatorRuntime {
 
     /// Launches an infinite loop ticking the state machine.
     pub async fn run(&mut self) {
-        info!("state machine: launching");
+        info!("STATE MACHINE: launching");
 
         loop {
             if let Err(e) = self.cycle().await {
-                error!("state machine: an error occurred: "; "error" => ?e);
+                error!("STATE MACHINE: an error occurred: "; "error" => ?e);
             }
 
             info!("Sleeping for {} ms", self.state_sleep.as_millis());
@@ -105,7 +112,7 @@ impl AggregatorRuntime {
     /// Perform one tick of the state machine.
     pub async fn cycle(&mut self) -> Result<(), RuntimeError> {
         info!("================================================================================");
-        info!("STATE MACHINE: new cycle"; "current_state" => self.state.to_string());
+        info!("STATE MACHINE: new cycle: {}", self.state);
 
         match self.state.clone() {
             AggregatorState::Idle(state) => {

mithril-common/src/entities/beacon.rs

@@ -2,6 +2,7 @@ use crate::entities::{Epoch, ImmutableFileNumber};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
 use std::cmp::Ordering;
+use std::fmt::{Display, Formatter};
 use thiserror::Error;
 
 /// Beacon represents a point in the Cardano chain at which a Mithril certificate should be produced
@@ -83,6 +84,16 @@ impl PartialOrd for Beacon {
     }
 }
 
+impl Display for Beacon {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "Beacon (network: {}, epoch: {}, immutable_file_number: {})",
+            self.network, self.epoch, self.immutable_file_number
+        )
+    }
+}
+
 impl Beacon {
     /// Beacon factory
     pub fn new(network: String, epoch: u64, immutable_file_number: ImmutableFileNumber) -> Beacon {

mithril-signer/src/runtime/state_machine.rs

@@ -50,10 +50,17 @@ impl SignerState {
 
 impl Display for SignerState {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match *self {
-            Self::Unregistered(_) => write!(f, "unregistered"),
-            Self::Registered(_) => write!(f, "registered"),
-            Self::Signed(_) => write!(f, "signed"),
+        match self {
+            Self::Unregistered(state) => write!(
+                f,
+                "Unregistered - {}",
+                match state {
+                    None => "No Epoch".to_string(),
+                    Some(e) => format!("Epoch({})", e),
+                }
+            ),
+            Self::Registered(state) => write!(f, "Registered - {}", state.beacon),
+            Self::Signed(state) => write!(f, "Signed - {}", state.beacon),
         }
     }
 }
@@ -86,11 +93,11 @@ impl StateMachine {
 
     /// Launch the state machine until an error occurs or it is interrupted.
     pub async fn run(&mut self) -> Result<(), Box<dyn Error>> {
-        info!("state machine: launching");
+        info!("STATE MACHINE: launching");
 
         loop {
             if let Err(e) = self.cycle().await {
-                error!("state machine: an error occured: "; "error" => ?e);
+                error!("STATE MACHINE: an error occured: "; "error" => ?e);
             }
 
             info!("Sleeping for {} ms", self.state_sleep.as_millis());
@@ -101,7 +108,7 @@ impl StateMachine {
     /// Perform a cycle of the state machine.
     pub async fn cycle(&mut self) -> Result<(), Box<dyn Error + Sync + Send>> {
         info!("================================================================================");
-        info!("STATE MACHINE: new cycle"; "current_state" => ?self.state);
+        info!("STATE MACHINE: new cycle: {}", self.state);
 
         match &self.state {
             SignerState::Unregistered(maybe_epoch) => {