Session stats: "got_block_by", "shard_configuration"

Author: SpyCheese

tl/generate/scheme/ton_api.tl

@@ -913,7 +913,7 @@ validatorStats.stats.producer flags:#
   validator_id:int256 block_status:int
   candidate_id:flags.0?int256 block_id:flags.0?tonNode.blockIdExt collated_data_hash:flags.0?int256
   is_accepted:flags.0?Bool is_ours:flags.0?Bool
-  got_block_at:flags.0?double got_submit_at:flags.0?double gen_utime:flags.0?int comment:flags.0?string
+  got_block_at:flags.0?double got_block_by:flags.0?int got_submit_at:flags.0?double gen_utime:flags.0?int comment:flags.0?string
   collation_time:flags.1?double collated_at:flags.1?double collation_cached:flags.1?Bool self_collated:flags.1?Bool collator_node_id:flags.2?int256
   validation_time:flags.3?double validated_at:flags.3?double validation_cached:flags.3?Bool
   approved_weight:flags.0?long approved_33pct_at:flags.0?double approved_66pct_at:flags.0?double approvers:flags.0?string
@@ -937,7 +937,7 @@ validatorStats.blockLimitsStatus
 validatorStats.extMsgsStats
     ext_msgs_total:int ext_msgs_filtered:int ext_msgs_accepted:int ext_msgs_rejected:int = validatorStats.ExtMsgsStats;
 validatorStats.blockStats
-    ext_msgs:validatorStats.extMsgsStats transactions:int = validatorStats.BlockStats;
+    ext_msgs:validatorStats.extMsgsStats transactions:int shard_configuration:(vector tonNode.blockIdExt) = validatorStats.BlockStats;
 
 validatorStats.collatedBlock
     block_id:tonNode.blockIdExt collated_data_hash:int256 cc_seqno:int collated_at:double

tl/generate/scheme/ton_api.tlo

@@ -73,6 +73,7 @@ struct ValidatorSessionNode {
 
 struct ValidatorSessionStats {
   enum { status_none = 0, status_received = 1, status_rejected = 2, status_approved = 3 };
+  enum { recv_none = 0, recv_collated = 1, recv_broadcast = 2, recv_query = 3, recv_cached = 4, recv_startup = 5 };
 
   struct Producer {
     int block_status = status_none;
@@ -83,6 +84,7 @@ struct ValidatorSessionStats {
     bool is_accepted = false;
     bool is_ours = false;
     double got_block_at = -1.0;
+    int got_block_by = 0;
     double got_submit_at = -1.0;
     td::int32 gen_utime = -1;
     std::string comment;
@@ -154,8 +156,8 @@ struct ValidatorSessionStats {
                : 0);
       return create_tl_object<ton_api::validatorStats_stats_producer>(
           flags, validator_id.bits256_value(), block_status, candidate_id, create_tl_block_id(block_id),
-          collated_data_hash, is_accepted, is_ours, got_block_at, got_submit_at, gen_utime, comment, collation_time,
-          collated_at, collation_cached, self_collated, collator_node_id, validation_time, validated_at,
+          collated_data_hash, is_accepted, is_ours, got_block_at, got_block_by, got_submit_at, gen_utime, comment,
+          collation_time, collated_at, collation_cached, self_collated, collator_node_id, validation_time, validated_at,
           validation_cached, approved_weight, approved_33pct_at, approved_66pct_at, std::move(approvers_str),
           signed_weight, signed_33pct_at, signed_66pct_at, std::move(signers_str), serialize_time, deserialize_time,
           serialized_size);

validator-session/validator-session-types.h

@@ -222,7 +222,7 @@ bool ValidatorSessionImpl::ensure_candidate_unique(td::uint32 src_idx, td::uint3
 
 void ValidatorSessionImpl::process_broadcast(PublicKeyHash src, td::BufferSlice data,
                                              td::optional<ValidatorSessionCandidateId> expected_id,
-                                             bool is_overlay_broadcast) {
+                                             bool is_overlay_broadcast, bool is_startup) {
   // Note: src is not necessarily equal to the sender of this message:
   // If requested using get_broadcast_p2p, src is the creator of the block, sender possibly is some other node.
   auto src_idx = description().get_source_idx(src);
@@ -269,6 +269,13 @@ void ValidatorSessionImpl::process_broadcast(PublicKeyHash src, td::BufferSlice
     }
     if (stat->got_block_at <= 0.0) {
       stat->got_block_at = td::Clocks::system();
+      if (is_overlay_broadcast) {
+        stat->got_block_by = ValidatorSessionStats::recv_broadcast;
+      } else if (is_startup) {
+        stat->got_block_by = ValidatorSessionStats::recv_startup;
+      } else {
+        stat->got_block_by = ValidatorSessionStats::recv_query;
+      }
     }
     stat->deserialize_time = deserialize_time;
     stat->serialized_size = data.size();
@@ -470,6 +477,7 @@ void ValidatorSessionImpl::generated_block(td::uint32 round, GeneratedCandidate
     stat->collation_time = collation_time;
     stat->collated_at = td::Clocks::system();
     stat->got_block_at = td::Clocks::system();
+    stat->got_block_by = ValidatorSessionStats::recv_collated;
     stat->collation_cached = c.is_cached;
     stat->self_collated = c.self_collated;
     stat->collator_node_id = c.collator_node_id;
@@ -610,6 +618,7 @@ void ValidatorSessionImpl::try_approve_block(const SentBlock *block) {
         }
         if (stat->got_block_at <= 0.0) {
           stat->got_block_at = td::Clocks::system();
+          stat->got_block_by = ValidatorSessionStats::recv_cached;
         }
         stat->block_id.root_hash = B->root_hash_;
         stat->block_id.file_hash = td::sha256_bits256(B->data_);
@@ -656,8 +665,9 @@ void ValidatorSessionImpl::try_approve_block(const SentBlock *block) {
                   VLOG(VALIDATOR_SESSION_WARNING) << print_id << ": failed to get candidate " << hash << " from " << id
                                                   << ": " << R.move_as_error();
                 } else {
+                  LOG(ERROR) << "QQQQQ Got block " << R.ok().size();
                   td::actor::send_closure(SelfId, &ValidatorSessionImpl::process_broadcast, src_id, R.move_as_ok(),
-                                          candidate_id, false);
+                                          candidate_id, false, false);
                 }
               });
 
@@ -971,8 +981,8 @@ void ValidatorSessionImpl::on_catchain_started() {
           auto broadcast = create_tl_object<ton_api::validatorSession_candidate>(
               src.tl(), round, root_hash, std::move(B.data), std::move(B.collated_data));
           td::actor::send_closure(SelfId, &ValidatorSessionImpl::process_broadcast, src,
-                                  serialize_candidate(broadcast, compress).move_as_ok(), td::optional<ValidatorSessionCandidateId>(),
-                                  false);
+                                  serialize_candidate(broadcast, compress).move_as_ok(),
+                                  td::optional<ValidatorSessionCandidateId>(), false, true);
         }
       });
       callback_->get_approved_candidate(description().get_source_public_key(x->get_src_idx()), x->get_root_hash(),

validator-session/validator-session.cpp

@@ -116,7 +116,7 @@ class ValidatorSessionImpl : public ValidatorSession {
       }
       void process_broadcast(const PublicKeyHash &src, td::BufferSlice data) override {
         td::actor::send_closure(id_, &ValidatorSessionImpl::process_broadcast, src, std::move(data),
-                                td::optional<ValidatorSessionCandidateId>(), true);
+                                td::optional<ValidatorSessionCandidateId>(), true, false);
       }
       void process_message(const PublicKeyHash &src, td::BufferSlice data) override {
         td::actor::send_closure(id_, &ValidatorSessionImpl::process_message, src, std::move(data));
@@ -204,7 +204,7 @@ class ValidatorSessionImpl : public ValidatorSession {
   void preprocess_block(catchain::CatChainBlock *block);
   bool ensure_candidate_unique(td::uint32 src_idx, td::uint32 round, ValidatorSessionCandidateId block_id);
   void process_broadcast(PublicKeyHash src, td::BufferSlice data, td::optional<ValidatorSessionCandidateId> expected_id,
-                         bool is_overlay_broadcast);
+                         bool is_overlay_broadcast, bool is_startup);
   void process_message(PublicKeyHash src, td::BufferSlice data);
   void process_query(PublicKeyHash src, td::BufferSlice data, td::Promise<td::BufferSlice> promise);
 

validator-session/validator-session.hpp

@@ -6374,6 +6374,12 @@ void Collator::finalize_stats() {
   stats_.work_time = work_time;
   stats_.cpu_work_time = cpu_work_time;
   stats_.time_stats = (PSTRING() << perf_log_);
+  if (is_masterchain() && shard_conf_) {
+    shard_conf_->process_shard_hashes([&](const block::McShardHash& shard) {
+      stats_.shard_configuration.push_back(shard.top_block_id());
+      return 0;
+    });
+  }
 }
 
 /**

validator/impl/collator.cpp

@@ -70,6 +70,7 @@ struct CollationStats {
   int cat_bytes = 0, cat_gas = 0, cat_lt_delta = 0, cat_collated_data_bytes = 0;
   std::string limits_log;
   td::uint32 transactions = 0;
+  std::vector<BlockIdExt> shard_configuration;
   td::uint32 ext_msgs_total = 0;
   td::uint32 ext_msgs_filtered = 0;
   td::uint32 ext_msgs_accepted = 0;
@@ -78,10 +79,14 @@ struct CollationStats {
   std::string time_stats;
 
   tl_object_ptr<ton_api::validatorStats_collatedBlock> tl() const {
+    std::vector<tl_object_ptr<ton_api::tonNode_blockIdExt>> shards;
+    for (const BlockIdExt& block_id : shard_configuration) {
+      shards.push_back(create_tl_block_id(block_id));
+    }
     auto block_stats = create_tl_object<ton_api::validatorStats_blockStats>(
         create_tl_object<ton_api::validatorStats_extMsgsStats>(ext_msgs_total, ext_msgs_filtered, ext_msgs_accepted,
                                                                ext_msgs_rejected),
-        transactions);
+        transactions, std::move(shards));
     return create_tl_object<ton_api::validatorStats_collatedBlock>(
         create_tl_block_id(block_id), collated_data_hash, cc_seqno, collated_at, actual_bytes,
         actual_collated_data_bytes, attempt, self.bits256_value(), is_validator, total_time, work_time, cpu_work_time,