Add more stats to validator getstats

1) Liteserver queries count
2) Collated/validated blocks count, number of active sessions
3) Persistent state sizes
4) Initial sync progress

Author: SpyCheese

tdutils/td/utils/Time.h

@@ -128,6 +128,10 @@ inline Timestamp &operator+=(Timestamp &a, double b) {
   return a;
 }
 
+inline double operator-(const Timestamp &a, const Timestamp &b) {
+  return a.at() - b.at();
+}
+
 template <class StorerT>
 void store(const Timestamp &timestamp, StorerT &storer) {
   storer.store_binary(timestamp.at() - Time::now() + Clocks::system());

validator-engine/validator-engine.cpp

@@ -1957,7 +1957,8 @@ void ValidatorEngine::started_overlays() {
 
 void ValidatorEngine::start_validator() {
   validator_options_.write().set_allow_blockchain_init(config_.validators.size() > 0);
-  validator_options_.write().set_state_serializer_enabled(config_.state_serializer_enabled);
+  validator_options_.write().set_state_serializer_enabled(config_.state_serializer_enabled &&
+                                                          !state_serializer_disabled_flag_);
   load_collator_options();
 
   validator_manager_ = ton::validator::ValidatorManagerFactory::create(
@@ -3973,7 +3974,7 @@ void ValidatorEngine::run_control_query(ton::ton_api::engine_validator_setStateS
     promise.set_value(ton::create_serialize_tl_object<ton::ton_api::engine_validator_success>());
     return;
   }
-  validator_options_.write().set_state_serializer_enabled(query.enabled_);
+  validator_options_.write().set_state_serializer_enabled(query.enabled_ && !state_serializer_disabled_flag_);
   td::actor::send_closure(validator_manager_, &ton::validator::ValidatorManagerInterface::update_options,
                           validator_options_);
   config_.state_serializer_enabled = query.enabled_;
@@ -4556,6 +4557,11 @@ int main(int argc, char *argv[]) {
               td::actor::send_closure(x, &ValidatorEngine::set_validator_telemetry_filename, s);
             });
       });
+  p.add_option(
+      '\0', "disable-state-serializer",
+      "disable persistent state serializer (similar to set-state-serializer-enabled 0 in validator console)", [&]() {
+        acts.push_back([&x]() { td::actor::send_closure(x, &ValidatorEngine::set_state_serializer_disabled_flag); });
+      });
   auto S = p.run(argc, argv);
   if (S.is_error()) {
     LOG(ERROR) << "failed to parse options: " << S.move_as_error();

validator-engine/validator-engine.hpp

@@ -228,6 +228,7 @@ class ValidatorEngine : public td::actor::Actor {
   std::string validator_telemetry_filename_;
   bool not_all_shards_ = false;
   std::vector<ton::ShardIdFull> add_shard_cmds_;
+  bool state_serializer_disabled_flag_ = false;
 
   std::set<ton::CatchainSeqno> unsafe_catchains_;
   std::map<ton::BlockSeqno, std::pair<ton::CatchainSeqno, td::uint32>> unsafe_catchain_rotations_;
@@ -325,6 +326,9 @@ class ValidatorEngine : public td::actor::Actor {
   void add_shard_cmd(ton::ShardIdFull shard) {
     add_shard_cmds_.push_back(shard);
   }
+  void set_state_serializer_disabled_flag() {
+    state_serializer_disabled_flag_ = true;
+  }
 
   void start_up() override;
   ValidatorEngine() {

validator/db/archive-manager.cpp

@@ -1196,6 +1196,30 @@ void ArchiveManager::set_async_mode(bool mode, td::Promise<td::Unit> promise) {
   }
 }
 
+void ArchiveManager::prepare_stats(td::Promise<std::vector<std::pair<std::string, std::string>>> promise) {
+  std::vector<std::pair<std::string, std::string>> stats;
+  {
+    std::map<BlockSeqno, td::uint64> states;
+    for (auto &[key, file] : perm_states_) {
+      BlockSeqno seqno = key.first;
+      auto r_stat = td::stat(db_root_ + "/archive/states/" + file.filename_short());
+      if (r_stat.is_error()) {
+        LOG(WARNING) << "Cannot stat persistent state file " << file.filename_short() << " : " << r_stat.move_as_error();
+      } else {
+        states[seqno] += r_stat.move_as_ok().size_;
+      }
+    }
+    td::StringBuilder sb;
+    for (auto &[seqno, size] : states) {
+      sb << seqno << ":" << td::format::as_size(size) << " ";
+    }
+    if (!sb.as_cslice().empty()) {
+      stats.emplace_back("persistent_states", sb.as_cslice().str());
+    }
+  }
+  promise.set_value(std::move(stats));
+}
+
 void ArchiveManager::truncate(BlockSeqno masterchain_seqno, ConstBlockHandle handle, td::Promise<td::Unit> promise) {
   index_->begin_transaction().ensure();
   td::MultiPromise mp;

validator/db/archive-manager.hpp

@@ -81,6 +81,8 @@ class ArchiveManager : public td::actor::Actor {
     cur_shard_split_depth_ = value;
   }
 
+  void prepare_stats(td::Promise<std::vector<std::pair<std::string, std::string>>> promise);
+
   static constexpr td::uint32 archive_size() {
     return 20000;
   }

validator/db/celldb.cpp

@@ -158,6 +158,17 @@ void CellDbIn::start_up() {
         },
         td::Timestamp::now());
   }
+
+  {
+    std::string key = "stats.last_deleted_mc_seqno", value;
+    auto R = cell_db_->get(td::as_slice(key), value);
+    R.ensure();
+    if (R.ok() == td::KeyValue::GetStatus::Ok) {
+      auto r_value = td::to_integer_safe<BlockSeqno>(value);
+      r_value.ensure();
+      last_deleted_mc_state_ = r_value.move_as_ok();
+    }
+  }
 }
 
 void CellDbIn::load_cell(RootHash hash, td::Promise<td::Ref<vm::DataCell>> promise) {
@@ -452,6 +463,11 @@ void CellDbIn::gc_cont2(BlockHandle handle) {
           cell_db_->erase(get_key(key_hash)).ensure();
           set_block(F.prev, std::move(P));
           set_block(F.next, std::move(N));
+          if (handle->id().is_masterchain()) {
+            last_deleted_mc_state_ = handle->id().seqno();
+            std::string key = "stats.last_deleted_mc_seqno", value = td::to_string(last_deleted_mc_state_);
+            cell_db_->set(td::as_slice(key), td::as_slice(value));
+          }
           cell_db_->commit_write_batch().ensure();
           alarm_timestamp() = td::Timestamp::now();
           timer_write_batch.reset();
@@ -475,9 +491,6 @@ void CellDbIn::gc_cont2(BlockHandle handle) {
           if (!opts_->get_disable_rocksdb_stats()) {
             cell_db_statistics_.gc_cell_time_.insert(timer.elapsed() * 1e6);
           }
-          if (handle->id().is_masterchain()) {
-            last_deleted_mc_state_ = handle->id().seqno();
-          }
           LOG(DEBUG) << "Deleted state " << handle->id().to_str();
           timer_finish.reset();
           timer_all.reset();

validator/db/rootdb.cpp

@@ -438,6 +438,7 @@ void RootDb::allow_block_gc(BlockIdExt block_id, td::Promise<bool> promise) {
 void RootDb::prepare_stats(td::Promise<std::vector<std::pair<std::string, std::string>>> promise) {
   auto merger = StatsMerger::create(std::move(promise));
   td::actor::send_closure(cell_db_, &CellDb::prepare_stats, merger.make_promise("celldb."));
+  td::actor::send_closure(archive_db_, &ArchiveManager::prepare_stats, merger.make_promise("archive."));
 }
 
 void RootDb::truncate(BlockSeqno seqno, ConstBlockHandle handle, td::Promise<td::Unit> promise) {

validator/downloaders/download-state.cpp

@@ -38,6 +38,7 @@ DownloadShardState::DownloadShardState(BlockIdExt block_id, BlockIdExt mastercha
 }
 
 void DownloadShardState::start_up() {
+  status_ = ProcessStatus(manager_, "process.download_state");
   alarm_timestamp() = timeout_;
 
   auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<BlockHandle> R) {
@@ -81,6 +82,7 @@ void DownloadShardState::download_state() {
   });
   td::actor::send_closure(manager_, &ValidatorManager::send_get_block_proof_link_request, block_id_, priority_,
                           std::move(P));
+  status_.set_status(PSTRING() << block_id_.id.to_str() << " : downloading proof");
 }
 
 void DownloadShardState::downloaded_proof_link(td::BufferSlice data) {
@@ -123,6 +125,7 @@ void DownloadShardState::checked_proof_link() {
     td::actor::send_closure(manager_, &ValidatorManager::send_get_persistent_state_request, block_id_,
                             masterchain_block_id_, priority_, std::move(P));
   }
+  status_.set_status(PSTRING() << block_id_.id.to_str() << " : downloading state");
 }
 
 void DownloadShardState::download_zero_state() {
@@ -152,6 +155,7 @@ void DownloadShardState::downloaded_zero_state(td::BufferSlice data) {
 }
 
 void DownloadShardState::downloaded_shard_state(td::BufferSlice data) {
+  status_.set_status(PSTRING() << block_id_.id.to_str() << " : processing downloaded state");
   auto S = create_shard_state(block_id_, data.clone());
   if (S.is_error()) {
     fail_handler(actor_id(this), S.move_as_error());
@@ -174,6 +178,7 @@ void DownloadShardState::downloaded_shard_state(td::BufferSlice data) {
 }
 
 void DownloadShardState::checked_shard_state() {
+  status_.set_status(PSTRING() << block_id_.id.to_str() << " : storing state file");
   LOG(WARNING) << "checked shard state " << block_id_.to_str();
   auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Unit> R) {
     R.ensure();
@@ -189,6 +194,7 @@ void DownloadShardState::checked_shard_state() {
 }
 
 void DownloadShardState::written_shard_state_file() {
+  status_.set_status(PSTRING() << block_id_.id.to_str() << " : storing state to celldb");
   LOG(WARNING) << "written shard state file " << block_id_.to_str();
   auto P = td::PromiseCreator::lambda([SelfId = actor_id(this)](td::Result<td::Ref<ShardState>> R) {
     R.ensure();
@@ -198,6 +204,7 @@ void DownloadShardState::written_shard_state_file() {
 }
 
 void DownloadShardState::written_shard_state(td::Ref<ShardState> state) {
+  status_.set_status(PSTRING() << block_id_.id.to_str() << " : finishing");
   state_ = std::move(state);
   handle_->set_unix_time(state_->get_unix_time());
   handle_->set_is_key_block(block_id_.is_masterchain());

validator/downloaders/download-state.hpp

@@ -19,6 +19,7 @@
 #pragma once
 
 #include "validator/interfaces/validator-manager.h"
+#include "stats-provider.h"
 
 namespace ton {
 
@@ -67,6 +68,8 @@ class DownloadShardState : public td::actor::Actor {
 
   td::BufferSlice data_;
   td::Ref<ShardState> state_;
+
+  ProcessStatus status_;
 };
 
 }  // namespace validator

validator/impl/collator-impl.h

@@ -50,7 +50,7 @@ class Collator final : public td::actor::Actor {
   using LtCellRef = block::LtCellRef;
   using NewOutMsg = block::NewOutMsg;
   const ShardIdFull shard_;
-  ton::BlockId new_id;
+  ton::BlockId new_id{workchainInvalid, 0, 0};
   bool busy_{false};
   bool before_split_{false};
   bool after_split_{false};