Merge pull request anza-xyz#6 from igalaxy-tech/tvc-rank

fix tvc rank

Author: OleksiiKuznietsov23

sentinel/src/main.rs

@@ -79,8 +79,8 @@ async fn main() -> anyhow::Result<()> {
                         Some(Ok(reports)) => {
                             tracing::info!("Computed TVC ranks!");
                             tvc_ranks_report_state.update_status(TVCRanksReportStatus::Completed);
-                            for (rank, (validator, total_credits, epoch_credits)) in reports.validators.into_iter().enumerate() {
-                                tvc_reports.insert(validator, (rank, total_credits, epoch_credits));
+                            for (rank, (validator, tvc_credits)) in reports.validators.into_iter().enumerate() {
+                                tvc_reports.insert(validator, (rank, tvc_credits));
                             }
                             //TODO: Store reports in db
                         }

sentinel/src/prometheus.rs

@@ -9,7 +9,7 @@ use url::Url;
 
 #[derive(Debug)]
 pub enum Report {
-    Validator((Box<ValidatorReport>, SmolStr, Option<(usize, u64, u64)>)),
+    Validator((Box<ValidatorReport>, SmolStr, Option<(usize, u64)>)),
 }
 
 #[derive(Debug)]
@@ -22,48 +22,46 @@ pub struct ValidatorMetrics {
     vote_latency: GaugeVec,
     tvc_rank: IntGaugeVec,
     steward_rank: IntGaugeVec,
-    total_credits: IntGaugeVec,
-    epoch_credits: IntGaugeVec,
+    tvc_credits: IntGaugeVec,
 }
 
 impl ValidatorMetrics {
     pub fn new(registry: &mut Registry) -> anyhow::Result<ValidatorMetrics> {
-        let epoch = IntGaugeVec::new(Opts::new("epoch", "Epoch"), &["pubkey", "data_center"])?;
+        let epoch = IntGaugeVec::new(
+            Opts::new("epoch", "Epoch"),
+            &["vote_account", "data_center"],
+        )?;
         let rank_by_stake = IntGaugeVec::new(
             Opts::new("rank_by_stake", "Rank by stake"),
-            &["pubkey", "data_center"],
+            &["vote_account", "data_center"],
         )?;
         let score = GaugeVec::new(
             Opts::new("score", "Steward Score"),
-            &["pubkey", "data_center"],
+            &["vote_account", "data_center"],
         )?;
         let yield_score = GaugeVec::new(
             Opts::new("yield_score", "Yield Score"),
-            &["pubkey", "data_center"],
+            &["vote_account", "data_center"],
         )?;
         let vote_credits_ratio = GaugeVec::new(
             Opts::new("vote_credits_ratio", "Vote credits ratio"),
-            &["pubkey", "data_center"],
+            &["vote_account", "data_center"],
         )?;
         let vote_latency = GaugeVec::new(
             Opts::new("vote_latency", "Vote latency"),
-            &["pubkey", "data_center"],
+            &["vote_account", "data_center"],
         )?;
         let tvc_rank = IntGaugeVec::new(
             Opts::new("tvc_rank", "TVC rank"),
-            &["pubkey", "data_center"],
+            &["vote_account", "data_center"],
         )?;
         let steward_rank = IntGaugeVec::new(
             Opts::new("steward_rank", "Steward Rank"),
-            &["pubkey", "data_center"],
-        )?;
-        let total_credits = IntGaugeVec::new(
-            Opts::new("total_credits", "Total Credits"),
-            &["pubkey", "data_center"],
+            &["vote_account", "data_center"],
         )?;
-        let epoch_credits = IntGaugeVec::new(
-            Opts::new("epoch_credits", "Epoch Credits"),
-            &["pubkey", "data_center"],
+        let tvc_credits = IntGaugeVec::new(
+            Opts::new("tvc_credits", "Tvc credits for current epoch"),
+            &["vote_account", "data_center"],
         )?;
 
         registry.register(Box::new(epoch.clone()))?;
@@ -74,8 +72,7 @@ impl ValidatorMetrics {
         registry.register(Box::new(vote_latency.clone()))?;
         registry.register(Box::new(tvc_rank.clone()))?;
         registry.register(Box::new(steward_rank.clone()))?;
-        registry.register(Box::new(total_credits.clone()))?;
-        registry.register(Box::new(epoch_credits.clone()))?;
+        registry.register(Box::new(tvc_credits.clone()))?;
 
         Ok(ValidatorMetrics {
             epoch,
@@ -86,52 +83,44 @@ impl ValidatorMetrics {
             vote_latency,
             tvc_rank,
             steward_rank,
-            total_credits,
-            epoch_credits,
+            tvc_credits,
         })
     }
 
     pub fn update_report(
         &self,
-        (report, data_center, tvc_report): (
-            Box<ValidatorReport>,
-            SmolStr,
-            Option<(usize, u64, u64)>,
-        ),
+        (report, data_center, tvc_report): (Box<ValidatorReport>, SmolStr, Option<(usize, u64)>),
     ) {
-        let pubkey = report.validator_score.vote_account.to_string();
-        let (tvc_rank, total_credits, epoch_credits) = tvc_report.unwrap_or_default();
+        let vote_account = report.validator_score.vote_account.to_string();
+        let (tvc_rank, tvc_credits) = tvc_report.unwrap_or_default();
 
         self.epoch
-            .with_label_values(&[&pubkey, &data_center])
+            .with_label_values(&[&vote_account, &data_center])
             .set(report.history_entry.epoch as i64);
         self.rank_by_stake
-            .with_label_values(&[&pubkey, &data_center])
+            .with_label_values(&[&vote_account, &data_center])
             .set(report.history_entry.rank as i64);
         self.score
-            .with_label_values(&[&pubkey, &data_center])
+            .with_label_values(&[&vote_account, &data_center])
             .set(report.validator_score.score);
         self.yield_score
-            .with_label_values(&[&pubkey, &data_center])
+            .with_label_values(&[&vote_account, &data_center])
             .set(report.validator_score.yield_score);
         self.vote_credits_ratio
-            .with_label_values(&[&pubkey, &data_center])
+            .with_label_values(&[&vote_account, &data_center])
             .set(report.validator_score.vote_credits_ratio);
         self.vote_latency
-            .with_label_values(&[&pubkey, &data_center])
+            .with_label_values(&[&vote_account, &data_center])
             .set(report.vote_latency);
         self.steward_rank
-            .with_label_values(&[&pubkey, &data_center])
+            .with_label_values(&[&vote_account, &data_center])
             .set((report.rank as i64) + 1);
         self.tvc_rank
-            .with_label_values(&[&pubkey, &data_center])
+            .with_label_values(&[&vote_account, &data_center])
             .set((tvc_rank as i64) + 1);
-        self.total_credits
-            .with_label_values(&[&pubkey, &data_center])
-            .set(total_credits as i64);
-        self.epoch_credits
-            .with_label_values(&[&pubkey, &data_center])
-            .set(epoch_credits as i64);
+        self.tvc_credits
+            .with_label_values(&[&vote_account, &data_center])
+            .set(tvc_credits as i64);
     }
 }
 

sentinel/src/tvc_ranks.rs

@@ -16,7 +16,7 @@ use crate::{
 
 #[derive(Debug)]
 pub struct TVCRanksReport {
-    pub validators: Vec<(Pubkey, u64, u64)>,
+    pub validators: Vec<(Pubkey, u64)>,
 }
 
 pub struct TVCRanksReportState {
@@ -93,11 +93,6 @@ impl TVCRanksReportState {
             .current
             .into_iter()
             .map(|info| {
-                let total_credits = info
-                    .epoch_credits
-                    .iter()
-                    .fold(0, |acc, (_, credits, _)| acc + credits);
-
                 let latest_credits = info
                     .epoch_credits
                     .into_iter()
@@ -107,12 +102,12 @@ impl TVCRanksReportState {
 
                 info.vote_pubkey
                     .parse()
-                    .map(|pk| (pk, total_credits, latest_credits))
+                    .map(|pk| (pk, latest_credits))
                     .map_err(anyhow::Error::from)
             })
-            .collect::<anyhow::Result<Vec<(Pubkey, _, _)>>>()?;
+            .collect::<anyhow::Result<Vec<(Pubkey, _)>>>()?;
 
-        validators_with_credits.sort_by(|(_, l, _), (_, r, _)| r.cmp(l));
+        validators_with_credits.sort_by(|(_, l), (_, r)| r.cmp(l));
 
         Ok(TVCRanksReport {
             validators: validators_with_credits,