external/ton
1
0
Fork 0
mirror of https://github.com/ton-blockchain/ton synced 2025-03-09 15:40:10 +00:00
Code Issues Releases Wiki Activity

Add "self" to all session stats records

Browse source
This commit is contained in:
SpyCheese 2024-12-27 12:20:45 +03:00
parent 71342bdcd4
commit e6984e4799
13 changed files with 47 additions and 38 deletions
Download patch file Download diff file Expand all files Collapse all files

11
tl/generate/scheme/ton_api.tl
View file

@ -923,16 +923,17 @@ validatorStats.blockLimitsStatus
validatorStats.extMsgsStats
ext_msgs_total:int ext_msgs_filtered:int ext_msgs_accepted:int ext_msgs_rejected:int = validatorStats.ExtMsgsStats;
validatorStats.collatedBlock flags:#
validatorStats.collatedBlock
block_id:tonNode.blockIdExt collated_data_hash:int256 cc_seqno:int collated_at:double
bytes:int collated_data_bytes:int attempt:int
collator_node_id:flags.0?int256 validator_id:flags.1?int256
self:int256 is_validator:Bool
total_time:double work_time:double cpu_work_time:double time_stats:string
block_limits:validatorStats.blockLimitsStatus
ext_msgs_stats:validatorStats.extMsgsStats = validatorSession.stats.CollatedBlock;
validatorStats.validatedBlock
block_id:tonNode.blockIdExt collated_data_hash:int256 validated_at:double
self:int256
valid:Bool comment:string
bytes:int collated_data_bytes:int
total_time:double work_time:double cpu_work_time:double = validatorStats.ValidatedBlock;
@ -940,13 +941,13 @@ validatorStats.validatedBlock
validatorStats.newValidatorGroup.node id:int256 weight:long = validatorStats.newValidatorGroup.Node;
validatorStats.newValidatorGroup session_id:int256 shard:tonNode.shardId cc_seqno:int
last_key_block_seqno:int started_at:double
self_idx:int nodes:(vector validatorStats.newValidatorGroup.node) = validatorStats.NewValidatorGroup;
self_idx:int self:int256 nodes:(vector validatorStats.newValidatorGroup.node) = validatorStats.NewValidatorGroup;
validatorStats.endValidatorGroup.node id:int256 catchain_blocks:int = validatorStats.endValidatorGroup.Node;
validatorStats.endValidatorGroup session_id:int256 timestamp:double
validatorStats.endValidatorGroup session_id:int256 timestamp:double self:int256
nodes:(vector validatorStats.endValidatorGroup.node) = validatorStats.EndValidatorGroup;
validatorStats.collatorNodeResponse collator_node_id:int256 validator_id:int256 timestamp:double
validatorStats.collatorNodeResponse self:int256 validator_id:int256 timestamp:double
block_id:tonNode.blockIdExt original_block_id:tonNode.blockIdExt collated_data_hash:int256
= validatorStats.CollatorNodeResponse;

BIN
tl/generate/scheme/ton_api.tlo
View file

Binary file not shown.

7
validator-session/validator-session-types.h
View file

@ -222,6 +222,7 @@ struct NewValidatorGroupStats {
BlockSeqno last_key_block_seqno = 0;
double started_at = -1.0;
td::uint32 self_idx = 0;
PublicKeyHash self = PublicKeyHash::zero();
std::vector<Node> nodes;
tl_object_ptr<ton_api::validatorStats_newValidatorGroup> tl() const {
@ -232,7 +233,7 @@ struct NewValidatorGroupStats {
}
return create_tl_object<ton_api::validatorStats_newValidatorGroup>(session_id, create_tl_shard_id(shard), cc_seqno,
last_key_block_seqno, started_at, self_idx,
std::move(nodes_arr));
self.bits256_value(), std::move(nodes_arr));
}
};
@ -244,6 +245,7 @@ struct EndValidatorGroupStats {
ValidatorSessionId session_id = ValidatorSessionId::zero();
double timestamp = -1.0;
PublicKeyHash self = PublicKeyHash::zero();
std::vector<Node> nodes;
tl_object_ptr<ton_api::validatorStats_endValidatorGroup> tl() const {
@ -252,7 +254,8 @@ struct EndValidatorGroupStats {
nodes_arr.push_back(create_tl_object<ton_api::validatorStats_endValidatorGroup_node>(node.id.bits256_value(),
node.catchain_blocks));
}
return create_tl_object<ton_api::validatorStats_endValidatorGroup>(session_id, timestamp, std::move(nodes_arr));
return create_tl_object<ton_api::validatorStats_endValidatorGroup>(session_id, timestamp, self.bits256_value(),
std::move(nodes_arr));
}
};

2
validator-session/validator-session.cpp
View file

@ -1036,7 +1036,7 @@ void ValidatorSessionImpl::get_end_stats(td::Promise<EndValidatorGroupStats> pro
promise.set_error(td::Status::Error(ErrorCode::notready, "not started"));
return;
}
EndValidatorGroupStats stats{.session_id = unique_hash_, .timestamp = td::Clocks::system()};
EndValidatorGroupStats stats{.session_id = unique_hash_, .timestamp = td::Clocks::system(), .self = local_id()};
stats.nodes.resize(description().get_total_nodes());
for (size_t i = 0; i < stats.nodes.size(); ++i) {
stats.nodes[i].id = description().get_source_id(i);

4
validator/collator-node.cpp
View file

@ -396,8 +396,8 @@ void CollatorNode::receive_query(adnl::AdnlNodeIdShort src, td::BufferSlice data
TRY_RESULT_PROMISE(new_promise, block, std::move(R));
CollatorNodeResponseStats stats;
stats.collator_node_id = local_id.bits256_value();
stats.validator_id = creator.as_bits256();
stats.self = local_id.pubkey_hash();
stats.validator_id = PublicKey(pubkeys::Ed25519(creator)).compute_short_id();
stats.original_block_id = block.id;
stats.collated_data_hash = block.collated_file_hash;

2
validator/fabric.h
View file

@ -82,7 +82,7 @@ void run_check_proof_query(BlockIdExt id, td::Ref<Proof> proof, td::actor::Actor
void run_check_proof_link_query(BlockIdExt id, td::Ref<ProofLink> proof, td::actor::ActorId<ValidatorManager> manager,
td::Timestamp timeout, td::Promise<BlockHandle> promise);
void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
BlockCandidate candidate, td::Ref<ValidatorSet> validator_set, PublicKeyHash local_validator_id,
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
void run_collate_query(ShardIdFull shard, const BlockIdExt& min_masterchain_block_id, std::vector<BlockIdExt> prev,

5
validator/impl/collator.cpp
View file

@ -5936,8 +5936,9 @@ bool Collator::create_block_candidate() {
stats_.actual_bytes = block_candidate->data.size();
stats_.actual_collated_data_bytes = block_candidate->collated_data.size();
stats_.attempt = attempt_idx_;
stats_.collator_node_id = collator_node_id_.bits256_value();
stats_.validator_id = created_by_.as_bits256();
stats_.is_validator = !(mode_ & CollateMode::from_collator_node);
stats_.self = stats_.is_validator ? PublicKey(pubkeys::Ed25519(created_by_)).compute_short_id()
: collator_node_id_.pubkey_hash();
stats_.estimated_bytes = block_limit_status_->estimate_block_size();
stats_.gas = block_limit_status_->gas_used;
stats_.lt_delta = block_limit_status_->cur_lt - block_limit_status_->limits.start_lt;

8
validator/impl/fabric.cpp
View file

@ -192,8 +192,8 @@ void run_check_proof_link_query(BlockIdExt id, td::Ref<ProofLink> proof, td::act
.release();
}
void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
std::vector<BlockIdExt> prev, BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
BlockCandidate candidate, td::Ref<ValidatorSet> validator_set, PublicKeyHash local_validator_id,
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
td::Promise<ValidateCandidateResult> promise, unsigned mode) {
BlockSeqno seqno = 0;
@ -207,8 +207,8 @@ void run_validate_query(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
td::actor::create_actor<ValidateQuery>(PSTRING() << (is_fake ? "fakevalidate" : "validateblock") << shard.to_str()
<< ":" << (seqno + 1) << "#" << idx.fetch_add(1),
shard, min_masterchain_block_id, std::move(prev), std::move(candidate),
std::move(validator_set), std::move(manager), timeout, std::move(promise),
mode)
std::move(validator_set), local_validator_id, std::move(manager), timeout,
std::move(promise), mode)
.release();
}

10
validator/impl/validate-query.cpp
View file

@ -67,16 +67,17 @@ std::string ErrorCtx::as_string() const {
* @param promise The Promise to return the ValidateCandidateResult to.
* @param mode +1 - fake mode
*/
ValidateQuery::ValidateQuery(ShardIdFull shard, BlockIdExt min_masterchain_block_id,
std::vector<BlockIdExt> prev, BlockCandidate candidate, Ref<ValidatorSet> validator_set,
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
td::Promise<ValidateCandidateResult> promise, unsigned mode)
ValidateQuery::ValidateQuery(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
BlockCandidate candidate, Ref<ValidatorSet> validator_set,
PublicKeyHash local_validator_id, td::actor::ActorId<ValidatorManager> manager,
td::Timestamp timeout, td::Promise<ValidateCandidateResult> promise, unsigned mode)
: shard_(shard)
, id_(candidate.id)
, min_mc_block_id(min_masterchain_block_id)
, prev_blocks(std::move(prev))
, block_candidate(std::move(candidate))
, validator_set_(std::move(validator_set))
, local_validator_id_(local_validator_id)
, manager(manager)
, timeout(timeout)
, main_promise(std::move(promise))
@ -7062,6 +7063,7 @@ void ValidateQuery::record_stats(bool valid, std::string error_message) {
stats.block_id = id_;
stats.collated_data_hash = block_candidate.collated_file_hash;
stats.validated_at = td::Clocks::system();
stats.self = local_validator_id_;
stats.valid = valid;
if (valid) {
stats.comment = (PSTRING() << "OK ts=" << now_);

3
validator/impl/validate-query.hpp
View file

@ -118,7 +118,7 @@ class ValidateQuery : public td::actor::Actor {
public:
ValidateQuery(ShardIdFull shard, BlockIdExt min_masterchain_block_id, std::vector<BlockIdExt> prev,
BlockCandidate candidate, td::Ref<ValidatorSet> validator_set,
BlockCandidate candidate, td::Ref<ValidatorSet> validator_set, PublicKeyHash local_validator_id,
td::actor::ActorId<ValidatorManager> manager, td::Timestamp timeout,
td::Promise<ValidateCandidateResult> promise, unsigned mode = 0);
@ -132,6 +132,7 @@ class ValidateQuery : public td::actor::Actor {
std::vector<Ref<ShardState>> prev_states;
BlockCandidate block_candidate;
td::Ref<ValidatorSet> validator_set_;
PublicKeyHash local_validator_id_ = PublicKeyHash::zero();
td::actor::ActorId<ValidatorManager> manager;
td::Timestamp timeout;
td::Promise<ValidateCandidateResult> main_promise;

24
validator/interfaces/validator-manager.h
View file

@ -62,8 +62,8 @@ struct CollationStats {
double collated_at = -1.0;
td::uint32 actual_bytes = 0, actual_collated_data_bytes = 0;
int attempt = 0;
td::Bits256 collator_node_id = td::Bits256::zero();
td::Bits256 validator_id = td::Bits256::zero();
PublicKeyHash self = PublicKeyHash::zero();
bool is_validator = false;
td::uint32 estimated_bytes = 0, gas = 0, lt_delta = 0, estimated_collated_data_bytes = 0;
int cat_bytes = 0, cat_gas = 0, cat_lt_delta = 0, cat_collated_data_bytes = 0;
std::string limits_log;
@ -75,11 +75,9 @@ struct CollationStats {
std::string time_stats;
tl_object_ptr<ton_api::validatorStats_collatedBlock> tl() const {
int flags = (collator_node_id.is_zero() ? 0 : ton_api::validatorStats_collatedBlock::Flags::COLLATOR_NODE_ID_MASK) |
(validator_id.is_zero() ? 0 : ton_api::validatorStats_collatedBlock::Flags::VALIDATOR_ID_MASK);
return create_tl_object<ton_api::validatorStats_collatedBlock>(
flags, create_tl_block_id(block_id), collated_data_hash, cc_seqno, collated_at, actual_bytes,
actual_collated_data_bytes, attempt, collator_node_id, validator_id, total_time, work_time, cpu_work_time,
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,
time_stats,
create_tl_object<ton_api::validatorStats_blockLimitsStatus>(estimated_bytes, gas, lt_delta,
estimated_collated_data_bytes, cat_bytes, cat_gas,
@ -93,6 +91,7 @@ struct ValidationStats {
BlockIdExt block_id;
td::Bits256 collated_data_hash = td::Bits256::zero();
double validated_at = -1.0;
PublicKeyHash self = PublicKeyHash::zero();
bool valid = false;
std::string comment;
td::uint32 actual_bytes = 0, actual_collated_data_bytes = 0;
@ -100,22 +99,23 @@ struct ValidationStats {
tl_object_ptr<ton_api::validatorStats_validatedBlock> tl() const {
return create_tl_object<ton_api::validatorStats_validatedBlock>(
create_tl_block_id(block_id), collated_data_hash, validated_at, valid, comment, actual_bytes,
actual_collated_data_bytes, total_time, work_time, cpu_work_time);
create_tl_block_id(block_id), collated_data_hash, validated_at, self.bits256_value(), valid, comment,
actual_bytes, actual_collated_data_bytes, total_time, work_time, cpu_work_time);
}
};
struct CollatorNodeResponseStats {
td::Bits256 collator_node_id = td::Bits256::zero();
td::Bits256 validator_id = td::Bits256::zero();
PublicKeyHash self = PublicKeyHash::zero();
PublicKeyHash validator_id = PublicKeyHash::zero();
double timestamp = -1.0;
BlockIdExt block_id, original_block_id;
td::Bits256 collated_data_hash = td::Bits256::zero();
tl_object_ptr<ton_api::validatorStats_collatorNodeResponse> tl() const {
return create_tl_object<ton_api::validatorStats_collatorNodeResponse>(
collator_node_id, validator_id, timestamp, create_tl_block_id(block_id), create_tl_block_id(original_block_id),
collated_data_hash);;
self.bits256_value(), validator_id.bits256_value(), timestamp, create_tl_block_id(block_id),
create_tl_block_id(original_block_id), collated_data_hash);
;
}
};

2
validator/manager-disk.cpp
View file

@ -153,7 +153,7 @@ void ValidatorManagerImpl::validate_fake(BlockCandidate candidate, std::vector<B
}
});
auto shard = candidate.id.shard_full();
run_validate_query(shard, last, prev, std::move(candidate), std::move(val_set), actor_id(this),
run_validate_query(shard, last, prev, std::move(candidate), std::move(val_set), PublicKeyHash::zero(), actor_id(this),
td::Timestamp::in(10.0), std::move(P), ValidateMode::fake);
}

7
validator/validator-group.cpp
View file

@ -155,8 +155,8 @@ void ValidatorGroup::validate_block_candidate(validatorsession::BlockSourceInfo
return;
}
VLOG(VALIDATOR_DEBUG) << "validating block candidate " << next_block_id;
run_validate_query(shard_, min_masterchain_block_id_, prev_block_ids_, std::move(block), validator_set_, manager_,
td::Timestamp::in(15.0), std::move(P));
run_validate_query(shard_, min_masterchain_block_id_, prev_block_ids_, std::move(block), validator_set_,
local_id_, manager_, td::Timestamp::in(15.0), std::move(P));
}
void ValidatorGroup::update_approve_cache(CacheKey key, UnixTime value) {
@ -413,7 +413,8 @@ void ValidatorGroup::start(std::vector<BlockIdExt> prev, BlockIdExt min_masterch
.shard = shard_,
.cc_seqno = validator_set_->get_catchain_seqno(),
.last_key_block_seqno = last_key_block_seqno_,
.started_at = td::Clocks::system()};
.started_at = td::Clocks::system(),
.self = local_id_};
td::uint32 idx = 0;
for (const auto &node : validator_set_->export_vector()) {
PublicKeyHash id = ValidatorFullId{node.key}.compute_short_id();