Merge pull request #5747 from stacks-network/chore/signer-coordinator-logging

chore: improve logging in `StackerDBListener`

Author: obycode

CHANGELOG.md

@@ -19,6 +19,7 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 - Logging improvements:
   - P2P logs now includes a reason for dropping a peer or neighbor
   - Improvements to how a PeerAddress is logged (human readable format vs hex)
+  - Add weight threshold and percentages to `StackerDBListener` logs
 
 ### Fixed
 

testnet/stacks-node/src/nakamoto_node/signer_coordinator.rs

@@ -341,11 +341,11 @@ impl SignerCoordinator {
                         return false;
                     }
                     // number or rejections changed?
-                    if status.total_reject_weight != rejections {
+                    if status.total_weight_rejected != rejections {
                         return false;
                     }
                     // enough signatures?
-                    return status.total_weight_signed < self.weight_threshold;
+                    return status.total_weight_approved < self.weight_threshold;
                 },
             )? {
                 Some(status) => status,
@@ -407,8 +407,8 @@ impl SignerCoordinator {
                 }
             };
 
-            if rejections != block_status.total_reject_weight {
-                rejections = block_status.total_reject_weight;
+            if rejections != block_status.total_weight_rejected {
+                rejections = block_status.total_weight_rejected;
                 let (rejections_step, new_rejections_timeout) = self
                     .block_rejection_timeout_steps
                     .range((Included(0), Included(rejections)))
@@ -430,18 +430,18 @@ impl SignerCoordinator {
             }
 
             if block_status
-                .total_reject_weight
+                .total_weight_rejected
                 .saturating_add(self.weight_threshold)
                 > self.total_weight
             {
                 info!(
                     "{}/{} signers vote to reject block",
-                    block_status.total_reject_weight, self.total_weight;
+                    block_status.total_weight_rejected, self.total_weight;
                     "block_signer_sighash" => %block_signer_sighash,
                 );
                 counters.bump_naka_rejected_blocks();
                 return Err(NakamotoNodeError::SignersRejected);
-            } else if block_status.total_weight_signed >= self.weight_threshold {
+            } else if block_status.total_weight_approved >= self.weight_threshold {
                 info!("Received enough signatures, block accepted";
                     "block_signer_sighash" => %block_signer_sighash,
                 );

testnet/stacks-node/src/nakamoto_node/stackerdb_listener.rs

@@ -54,8 +54,8 @@ pub static EVENT_RECEIVER_POLL: Duration = Duration::from_millis(500);
 pub struct BlockStatus {
     pub responded_signers: HashSet<StacksPublicKey>,
     pub gathered_signatures: BTreeMap<u32, MessageSignature>,
-    pub total_weight_signed: u32,
-    pub total_reject_weight: u32,
+    pub total_weight_approved: u32,
+    pub total_weight_rejected: u32,
 }
 
 #[derive(Debug, Clone)]
@@ -312,14 +312,17 @@ impl StackerDBListener {
                                 "signer_slot_id" => slot_id,
                                 "signature" => %signature,
                                 "signer_weight" => signer_entry.weight,
-                                "total_weight_signed" => block.total_weight_signed,
+                                "total_weight_approved" => block.total_weight_approved,
+                                "percent_approved" => block.total_weight_approved as f64 / self.total_weight as f64 * 100.0,
+                                "total_weight_rejected" => block.total_weight_rejected,
+                                "percent_rejected" => block.total_weight_rejected as f64 / self.total_weight as f64 * 100.0,
                             );
                             continue;
                         }
 
                         if !block.gathered_signatures.contains_key(&slot_id) {
-                            block.total_weight_signed = block
-                                .total_weight_signed
+                            block.total_weight_approved = block
+                                .total_weight_approved
                                 .checked_add(signer_entry.weight)
                                 .expect("FATAL: total weight signed exceeds u32::MAX");
                         }
@@ -330,14 +333,18 @@ impl StackerDBListener {
                             "signer_slot_id" => slot_id,
                             "signature" => %signature,
                             "signer_weight" => signer_entry.weight,
-                            "total_weight_signed" => block.total_weight_signed,
+                            "total_weight_approved" => block.total_weight_approved,
+                            "percent_approved" => block.total_weight_approved as f64 / self.total_weight as f64 * 100.0,
+                            "total_weight_rejected" => block.total_weight_rejected,
+                            "percent_rejected" => block.total_weight_rejected as f64 / self.total_weight as f64 * 100.0,
+                            "weight_threshold" => self.weight_threshold,
                             "tenure_extend_timestamp" => tenure_extend_timestamp,
                             "server_version" => metadata.server_version,
                         );
                         block.gathered_signatures.insert(slot_id, signature);
                         block.responded_signers.insert(signer_pubkey);
 
-                        if block.total_weight_signed >= self.weight_threshold {
+                        if block.total_weight_approved >= self.weight_threshold {
                             // Signal to anyone waiting on this block that we have enough signatures
                             cvar.notify_all();
                         }
@@ -378,8 +385,8 @@ impl StackerDBListener {
                             }
                         };
                         block.responded_signers.insert(rejected_pubkey);
-                        block.total_reject_weight = block
-                            .total_reject_weight
+                        block.total_weight_rejected = block
+                            .total_weight_rejected
                             .checked_add(signer_entry.weight)
                             .expect("FATAL: total weight rejected exceeds u32::MAX");
 
@@ -389,15 +396,19 @@ impl StackerDBListener {
                             "signer_slot_id" => slot_id,
                             "signature" => %rejected_data.signature,
                             "signer_weight" => signer_entry.weight,
-                            "total_weight_signed" => block.total_weight_signed,
+                            "total_weight_approved" => block.total_weight_approved,
+                            "percent_approved" => block.total_weight_approved as f64 / self.total_weight as f64 * 100.0,
+                            "total_weight_rejected" => block.total_weight_rejected,
+                            "percent_rejected" => block.total_weight_rejected as f64 / self.total_weight as f64 * 100.0,
+                            "weight_threshold" => self.weight_threshold,
                             "reason" => rejected_data.reason,
                             "reason_code" => ?rejected_data.reason_code,
                             "tenure_extend_timestamp" => rejected_data.response_data.tenure_extend_timestamp,
                             "server_version" => rejected_data.metadata.server_version,
                         );
 
                         if block
-                            .total_reject_weight
+                            .total_weight_rejected
                             .saturating_add(self.weight_threshold)
                             > self.total_weight
                         {
@@ -479,8 +490,8 @@ impl StackerDBListenerComms {
         let block_status = BlockStatus {
             responded_signers: HashSet::new(),
             gathered_signatures: BTreeMap::new(),
-            total_weight_signed: 0,
-            total_reject_weight: 0,
+            total_weight_approved: 0,
+            total_weight_rejected: 0,
         };
         blocks.insert(block.signer_signature_hash(), block_status);
     }