Log validator session stats to file

validator/interfaces/validator-manager.h

@@ -28,6 +28,7 @@
 #include "validator/validator.h"
 #include "liteserver.h"
 #include "crypto/vm/db/DynamicBagOfCellsDb.h"
+#include "validator-session/validator-session-types.h"
 
 namespace ton {
 
@@ -166,6 +167,8 @@ class ValidatorManager : public ValidatorManagerInterface {
 
   virtual void wait_shard_client_state(BlockSeqno seqno, td::Timestamp timeout, td::Promise<td::Unit> promise) = 0;
 
+  virtual void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) = 0;
+
   static bool is_persistent_state(UnixTime ts, UnixTime prev_ts) {
     return ts / (1 << 17) != prev_ts / (1 << 17);
   }

validator/manager-disk.hpp

@@ -364,6 +364,9 @@ class ValidatorManagerImpl : public ValidatorManager {
   void wait_shard_client_state(BlockSeqno seqno, td::Timestamp timeout, td::Promise<td::Unit> promise) override {
     UNREACHABLE();
   }
+  void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) override {
+    UNREACHABLE();
+  }
 
  private:
   PublicKeyHash local_id_;

validator/manager-hardfork.hpp

@@ -423,6 +423,9 @@ class ValidatorManagerImpl : public ValidatorManager {
   void wait_shard_client_state(BlockSeqno seqno, td::Timestamp timeout, td::Promise<td::Unit> promise) override {
     UNREACHABLE();
   }
+  void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) override {
+    UNREACHABLE();
+  }
 
  private:
   td::Ref<ValidatorManagerOptions> opts_;

validator/manager.cpp

@@ -26,6 +26,7 @@
 #include "fabric.h"
 #include "manager.h"
 #include "validate-broadcast.hpp"
+#include "ton/ton-tl.hpp"
 #include "ton/ton-io.hpp"
 #include "state-serializer.hpp"
 #include "get-next-key-blocks.h"
@@ -33,14 +34,19 @@
 
 #include "auto/tl/lite_api.h"
 #include "tl-utils/lite-utils.hpp"
+#include "auto/tl/ton_api_json.h"
+#include "tl/tl_json.h"
 
 #include "td/utils/Random.h"
 #include "td/utils/port/path.h"
+#include "td/utils/JsonBuilder.h"
 
 #include "common/delay.h"
 
 #include "validator/stats-merger.h"
 
+#include <fstream>
+
 namespace ton {
 
 namespace validator {
@@ -2511,6 +2517,31 @@ void ValidatorManagerImpl::wait_shard_client_state(BlockSeqno seqno, td::Timesta
   shard_client_waiters_[seqno].waiting_.emplace_back(timeout, 0, std::move(promise));
 }
 
+void ValidatorManagerImpl::log_validator_session_stats(BlockIdExt block_id,
+                                                       validatorsession::ValidatorSessionStats stats) {
+  std::string fname = opts_->get_session_logs_file();
+  if (fname.empty()) {
+    return;
+  }
+  std::vector<td::Bits256> producers;
+  for (const PublicKeyHash& id : stats.producers) {
+    producers.push_back(id.bits256_value());
+  }
+  auto obj = create_tl_object<ton_api::validatorSession_stats>(
+      create_tl_block_id_simple(block_id.id), stats.round, stats.total_validators, stats.total_weight,
+      stats.signatures, stats.signatures_weight, stats.approve_signatures, stats.approve_signatures_weight,
+      stats.creator.bits256_value(), std::move(producers));
+  std::string s = td::json_encode<std::string>(td::ToJson(*obj.get()), false);
+  s.erase(std::remove_if(s.begin(), s.end(), [](char c) { return c == '\n' || c == '\r'; }), s.end());
+
+  std::ofstream file;
+  file.open(fname, std::ios_base::app);
+  file << s << "\n";
+  file.close();
+
+  LOG(INFO) << "Writing validator session stats for " << block_id.id;
+}
+
 td::actor::ActorOwn<ValidatorManagerInterface> ValidatorManagerFactory::create(
     td::Ref<ValidatorManagerOptions> opts, std::string db_root, td::actor::ActorId<keyring::Keyring> keyring,
     td::actor::ActorId<adnl::Adnl> adnl, td::actor::ActorId<rldp::Rldp> rldp,

validator/manager.hpp

@@ -530,6 +530,8 @@ class ValidatorManagerImpl : public ValidatorManager {
 
   void wait_shard_client_state(BlockSeqno seqno, td::Timestamp timeout, td::Promise<td::Unit> promise) override;
 
+  void log_validator_session_stats(BlockIdExt block_id, validatorsession::ValidatorSessionStats stats) override;
+
  private:
   td::Timestamp resend_shard_blocks_at_;
   td::Timestamp check_waiters_at_;

validator/validator-group.cpp

@@ -85,6 +85,7 @@ void ValidatorGroup::accept_block_candidate(td::uint32 round_id, PublicKeyHash s
                                             RootHash root_hash, FileHash file_hash,
                                             std::vector<BlockSignature> signatures,
                                             std::vector<BlockSignature> approve_signatures,
+                                            validatorsession::ValidatorSessionStats stats,
                                             td::Promise<td::Unit> promise) {
   if (round_id >= last_known_round_id_) {
     last_known_round_id_ = round_id + 1;
@@ -95,11 +96,12 @@ void ValidatorGroup::accept_block_candidate(td::uint32 round_id, PublicKeyHash s
   validator_set_->check_approve_signatures(root_hash, file_hash, approve_sig_set).ensure();
 
   if (!started_) {
-    postoned_accept_.push_back(PostponedAccept{root_hash, file_hash, std::move(block_data), std::move(sig_set),
-                                               std::move(approve_sig_set), std::move(promise)});
+    postponed_accept_.push_back(PostponedAccept{root_hash, file_hash, std::move(block_data), std::move(sig_set),
+                                                std::move(approve_sig_set), std::move(stats), std::move(promise)});
     return;
   }
   auto next_block_id = create_next_block_id(root_hash, file_hash);
+  td::actor::send_closure(manager_, &ValidatorManager::log_validator_session_stats, next_block_id, std::move(stats));
   auto block =
       block_data.size() > 0 ? create_block(next_block_id, std::move(block_data)).move_as_ok() : td::Ref<BlockData>{};
 
@@ -198,7 +200,8 @@ std::unique_ptr<validatorsession::ValidatorSession::Callback> ValidatorGroup::ma
     void on_block_committed(td::uint32 round, PublicKey source, validatorsession::ValidatorSessionRootHash root_hash,
                             validatorsession::ValidatorSessionFileHash file_hash, td::BufferSlice data,
                             std::vector<std::pair<PublicKeyHash, td::BufferSlice>> signatures,
-                            std::vector<std::pair<PublicKeyHash, td::BufferSlice>> approve_signatures) override {
+                            std::vector<std::pair<PublicKeyHash, td::BufferSlice>> approve_signatures,
+                            validatorsession::ValidatorSessionStats stats) override {
       std::vector<BlockSignature> sigs;
       for (auto &sig : signatures) {
         sigs.emplace_back(BlockSignature{sig.first.bits256_value(), std::move(sig.second)});
@@ -210,7 +213,7 @@ std::unique_ptr<validatorsession::ValidatorSession::Callback> ValidatorGroup::ma
       auto P = td::PromiseCreator::lambda([](td::Result<td::Unit>) {});
       td::actor::send_closure(id_, &ValidatorGroup::accept_block_candidate, round, source.compute_short_id(),
                               std::move(data), root_hash, file_hash, std::move(sigs), std::move(approve_sigs),
-                              std::move(P));
+                              std::move(stats), std::move(P));
     }
     void on_block_skipped(td::uint32 round) override {
       td::actor::send_closure(id_, &ValidatorGroup::skip_round, round);
@@ -281,8 +284,10 @@ void ValidatorGroup::start(std::vector<BlockIdExt> prev, BlockIdExt min_masterch
     td::actor::send_closure(session_, &validatorsession::ValidatorSession::start);
   }
 
-  for (auto &p : postoned_accept_) {
+  for (auto &p : postponed_accept_) {
     auto next_block_id = create_next_block_id(p.root_hash, p.file_hash);
+    td::actor::send_closure(manager_, &ValidatorManager::log_validator_session_stats, next_block_id,
+                            std::move(p.stats));
 
     auto block =
         p.block.size() > 0 ? create_block(next_block_id, std::move(p.block)).move_as_ok() : td::Ref<BlockData>{};
@@ -290,7 +295,7 @@ void ValidatorGroup::start(std::vector<BlockIdExt> prev, BlockIdExt min_masterch
                              std::move(p.approve_sigs), std::move(p.promise));
     prev_block_ids_ = std::vector<BlockIdExt>{next_block_id};
   }
-  postoned_accept_.clear();
+  postponed_accept_.clear();
 }
 
 void ValidatorGroup::destroy() {

validator/validator-group.hpp

@@ -36,7 +36,8 @@ class ValidatorGroup : public td::actor::Actor {
   void validate_block_candidate(td::uint32 round_id, BlockCandidate block, td::Promise<td::uint32> promise);
   void accept_block_candidate(td::uint32 round_id, PublicKeyHash src, td::BufferSlice block, RootHash root_hash,
                               FileHash file_hash, std::vector<BlockSignature> signatures,
-                              std::vector<BlockSignature> approve_signatures, td::Promise<td::Unit> promise);
+                              std::vector<BlockSignature> approve_signatures,
+                              validatorsession::ValidatorSessionStats stats, td::Promise<td::Unit> promise);
   void skip_round(td::uint32 round);
   void retry_accept_block_query(BlockIdExt block_id, td::Ref<BlockData> block, std::vector<BlockIdExt> prev,
                                 td::Ref<BlockSignatureSet> sigs, td::Ref<BlockSignatureSet> approve_sigs,
@@ -85,10 +86,11 @@ class ValidatorGroup : public td::actor::Actor {
     td::BufferSlice block;
     td::Ref<BlockSignatureSet> sigs;
     td::Ref<BlockSignatureSet> approve_sigs;
+    validatorsession::ValidatorSessionStats stats;
     td::Promise<td::Unit> promise;
   };
 
-  std::list<PostponedAccept> postoned_accept_;
+  std::list<PostponedAccept> postponed_accept_;
 
   ShardIdFull shard_;
   PublicKeyHash local_id_;

validator/validator-options.hpp

@@ -111,6 +111,9 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
   BlockSeqno sync_upto() const override {
     return sync_upto_;
   }
+  std::string get_session_logs_file() const override {
+    return session_logs_file_;
+  }
 
   void set_zero_block_id(BlockIdExt block_id) override {
     zero_block_id_ = block_id;
@@ -161,6 +164,9 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
   void set_sync_upto(BlockSeqno seqno) override {
     sync_upto_ = seqno;
   }
+  void set_session_logs_file(std::string f) override {
+    session_logs_file_ = std::move(f);
+  }
 
   ValidatorManagerOptionsImpl *make_copy() const override {
     return new ValidatorManagerOptionsImpl(*this);
@@ -202,6 +208,7 @@ struct ValidatorManagerOptionsImpl : public ValidatorManagerOptions {
   std::map<CatchainSeqno, std::pair<BlockSeqno, td::uint32>> unsafe_catchain_rotates_;
   BlockSeqno truncate_{0};
   BlockSeqno sync_upto_{0};
+  std::string session_logs_file_;
 };
 
 }  // namespace validator

validator/validator.h

@@ -73,6 +73,7 @@ struct ValidatorManagerOptions : public td::CntObject {
   virtual bool need_db_truncate() const = 0;
   virtual BlockSeqno get_truncate_seqno() const = 0;
   virtual BlockSeqno sync_upto() const = 0;
+  virtual std::string get_session_logs_file() const = 0;
 
   virtual void set_zero_block_id(BlockIdExt block_id) = 0;
   virtual void set_init_block_id(BlockIdExt block_id) = 0;
@@ -91,6 +92,7 @@ struct ValidatorManagerOptions : public td::CntObject {
   virtual void add_unsafe_catchain_rotate(BlockSeqno seqno, CatchainSeqno cc_seqno, td::uint32 value) = 0;
   virtual void truncate_db(BlockSeqno seqno) = 0;
   virtual void set_sync_upto(BlockSeqno seqno) = 0;
+  virtual void set_session_logs_file(std::string f) = 0;
 
   static td::Ref<ValidatorManagerOptions> create(
       BlockIdExt zero_block_id, BlockIdExt init_block_id,