Add missing metrics

core/consensus/babe/impl/babe_impl.cpp

@@ -40,7 +40,11 @@
 namespace {
   constexpr const char *kBlockProposalTime =
       "kagome_proposer_block_constructed";
-}
+
+  constexpr const char *kIsMajorSyncing = "kagome_sub_libp2p_is_major_syncing";
+  constexpr const char *kIsRelayChainValidator =
+      "kagome_node_is_active_validator";
+}  // namespace
 
 using namespace std::literals::chrono_literals;
 
@@ -143,6 +147,19 @@ namespace kagome::consensus::babe {
         kBlockProposalTime,
         {0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10});
 
+    metrics_registry_->registerGaugeFamily(
+        kIsMajorSyncing, "Whether the node is performing a major sync or not.");
+    metric_is_major_syncing_ =
+        metrics_registry_->registerGaugeMetric(kIsMajorSyncing);
+    metric_is_major_syncing_->set(!was_synchronized_);
+    metrics_registry_->registerGaugeFamily(
+        kIsRelayChainValidator,
+        "Tracks if the validator is in the active set. Updates at session "
+        "boundary.");
+    metric_is_relaychain_validator_ =
+        metrics_registry_->registerGaugeMetric(kIsRelayChainValidator);
+    metric_is_relaychain_validator_->set(false);
+
     app_state_manager_->takeControl(*this);
   }
 
@@ -842,7 +859,7 @@ namespace kagome::consensus::babe {
 
       telemetry_->notifyWasSynchronized();
     }
-
+    metric_is_major_syncing_->set(!was_synchronized_);
     current_state_ = Babe::State::SYNCHRONIZED;
 
     babe_status_observable_->notify(
@@ -940,10 +957,12 @@ namespace kagome::consensus::babe {
       auto &babe_config = *babe_config_opt.value();
       auto keypair = session_keys_->getBabeKeyPair(babe_config.authorities);
       if (not keypair) {
-        SL_ERROR(log_,
-                 "Authority not known, skipping slot processing. "
-                 "Probably authority list has changed.");
+        metric_is_relaychain_validator_->set(false);
+        SL_TRACE(log_,
+                 "Not a validator for current authority set (epoch {})",
+                 current_epoch_.epoch_number);
       } else {
+        metric_is_relaychain_validator_->set(true);
         keypair_ = std::move(keypair->first);
         const auto &authority_index = keypair->second;
         if (lottery_->getEpoch() != current_epoch_) {

core/consensus/babe/impl/babe_impl.hpp

@@ -258,6 +258,8 @@ namespace kagome::consensus::babe {
     // Metrics
     metrics::RegistryPtr metrics_registry_ = metrics::createRegistry();
     metrics::Histogram *metric_block_proposal_time_;
+    metrics::Gauge *metric_is_major_syncing_;
+    metrics::Gauge *metric_is_relaychain_validator_;
 
     log::Logger log_;
     telemetry::Telemetry telemetry_;  // telemetry

core/network/impl/peer_manager_impl.cpp

@@ -17,6 +17,7 @@
 
 namespace {
   constexpr const char *syncPeerMetricName = "kagome_sync_peers";
+  constexpr const char *kPeersCountMetricName = "kagome_sub_libp2p_peers_count";
   /// Reputation change for a node when we get disconnected from it.
   static constexpr int32_t kDisconnectReputation = -256;
 }  // namespace
@@ -109,8 +110,12 @@ namespace kagome::network {
     // Register metrics
     registry_->registerGaugeFamily(syncPeerMetricName,
                                    "Number of peers we sync with");
+    registry_->registerGaugeFamily(kPeersCountMetricName,
+                                   "Number of connected peers");
     sync_peer_num_ = registry_->registerGaugeMetric(syncPeerMetricName);
     sync_peer_num_->set(0);
+    peers_count_metric_ = registry_->registerGaugeMetric(kPeersCountMetricName);
+    peers_count_metric_->set(0);
 
     app_state_manager_->takeControl(*this);
   }
@@ -172,6 +177,7 @@ namespace kagome::network {
                 self->connecting_peers_.erase(peer_id);
                 self->peer_view_->removePeer(peer_id);
                 self->sync_peer_num_->set(self->active_peers_.size());
+                self->peers_count_metric_->set(self->active_peers_.size());
                 SL_DEBUG(self->log_,
                          "Remained {} active peers",
                          self->active_peers_.size());
@@ -650,6 +656,7 @@ namespace kagome::network {
                            self->peers_in_queue_.size());
                 }
                 self->sync_peer_num_->set(self->active_peers_.size());
+                self->peers_count_metric_->set(self->active_peers_.size());
               }
 
               self->connecting_peers_.erase(peer_id);

core/network/impl/peer_manager_impl.hpp

@@ -203,6 +203,7 @@ namespace kagome::network {
     // metrics
     metrics::RegistryPtr registry_ = metrics::createRegistry();
     metrics::Gauge *sync_peer_num_;
+    metrics::Gauge *peers_count_metric_;
 
     // parachain
     std::shared_ptr<network::PeerView> peer_view_;

core/parachain/validator/impl/parachain_processor.cpp

@@ -56,6 +56,11 @@ OUTCOME_CPP_DEFINE_CATEGORY(kagome::parachain,
   return "Unknown parachain processor error";
 }
 
+namespace {
+  constexpr const char *kIsParachainValidator =
+      "kagome_node_is_parachain_validator";
+}
+
 namespace kagome::parachain {
 
   ParachainProcessorImpl::ParachainProcessorImpl(
@@ -114,6 +119,16 @@ namespace kagome::parachain {
     BOOST_ASSERT(babe_status_observable_);
     BOOST_ASSERT(query_audi_);
     app_state_manager->takeControl(*this);
+
+    metrics_registry_->registerGaugeFamily(
+        kIsParachainValidator,
+        "Tracks if the validator participates in parachain consensus. "
+        "Parachain validators are a subset of the active set validators that "
+        "perform approval checking of all parachain candidates in a session. "
+        "Updates at session boundary.");
+    metric_is_parachain_validator_ =
+        metrics_registry_->registerGaugeMetric(kIsParachainValidator);
+    metric_is_parachain_validator_->set(false);
   }
 
   bool ParachainProcessorImpl::prepare() {
@@ -261,6 +276,12 @@ namespace kagome::parachain {
     pm_->getStreamEngine()->broadcast(router_->getValidationProtocol(), msg);
   }
 
+  outcome::result<std::optional<ValidatorSigner>>
+  ParachainProcessorImpl::isParachainValidator(
+      const primitives::BlockHash &relay_parent) const {
+    return signer_factory_->at(relay_parent);
+  }
+
   outcome::result<void> ParachainProcessorImpl::canProcessParachains() const {
     if (!isValidatingNode()) {
       return Error::NOT_A_VALIDATOR;
@@ -279,16 +300,21 @@ namespace kagome::parachain {
   outcome::result<kagome::parachain::ParachainProcessorImpl::RelayParentState>
   ParachainProcessorImpl::initNewBackingTask(
       const primitives::BlockHash &relay_parent) {
+    bool is_parachain_validator = false;
+    auto metric_updater = gsl::finally([self{this}, &is_parachain_validator] {
+      self->metric_is_parachain_validator_->set(is_parachain_validator);
+    });
     OUTCOME_TRY(validators, parachain_host_->validators(relay_parent));
     OUTCOME_TRY(groups, parachain_host_->validator_groups(relay_parent));
     OUTCOME_TRY(cores, parachain_host_->availability_cores(relay_parent));
-    OUTCOME_TRY(validator, signer_factory_->at(relay_parent));
+    OUTCOME_TRY(validator, isParachainValidator(relay_parent));
     auto &[validator_groups, group_rotation_info] = groups;
 
     if (!validator) {
-      logger_->error("Not a validator, or no para keys.");
+      SL_TRACE(logger_, "Not a validator, or no para keys.");
       return Error::KEY_NOT_PRESENT;
     }
+    is_parachain_validator = true;
 
     const auto n_cores = cores.size();
     std::optional<ParachainId> assignment;
@@ -451,10 +477,6 @@ namespace kagome::parachain {
   void ParachainProcessorImpl::onValidationProtocolMsg(
       const libp2p::peer::PeerId &peer_id,
       const network::ValidatorProtocolMessage &message) {
-    if (auto r = canProcessParachains(); r.has_error()) {
-      return;
-    }
-
     if (auto m{boost::get<network::BitfieldDistributionMessage>(&message)}) {
       auto bd{boost::get<network::BitfieldDistribution>(m)};
       BOOST_ASSERT_MSG(
@@ -470,6 +492,13 @@ namespace kagome::parachain {
 
     if (auto msg{boost::get<network::StatementDistributionMessage>(&message)}) {
       if (auto statement_msg{boost::get<network::Seconded>(msg)}) {
+        if (auto r = canProcessParachains(); r.has_error()) {
+          return;
+        }
+        if (auto r = isParachainValidator(statement_msg->relay_parent);
+            r.has_error() || !r.value()) {
+          return;
+        }
         SL_TRACE(
             logger_, "Imported statement on {}", statement_msg->relay_parent);
         handleStatement(

core/parachain/validator/parachain_processor.hpp

@@ -22,6 +22,7 @@
 #include "authority_discovery/query/query.hpp"
 #include "common/visitor.hpp"
 #include "crypto/hasher.hpp"
+#include "metrics/metrics.hpp"
 #include "network/peer_manager.hpp"
 #include "network/peer_view.hpp"
 #include "network/protocols/req_collation_protocol.hpp"
@@ -222,6 +223,8 @@ namespace kagome::parachain {
         size_t validity_threshold);
     std::optional<BackingStore::BackedCandidate> table_attested_to_backed(
         AttestedCandidate &&attested, TableContext &table_context);
+    outcome::result<std::optional<ValidatorSigner>> isParachainValidator(
+        const primitives::BlockHash &relay_parent) const;
 
     /*
      * Logic.
@@ -431,6 +434,9 @@ namespace kagome::parachain {
 
     std::shared_ptr<primitives::events::ChainEventSubscriber> chain_sub_;
     std::shared_ptr<ThreadHandler> thread_handler_;
+
+    metrics::RegistryPtr metrics_registry_ = metrics::createRegistry();
+    metrics::Gauge *metric_is_parachain_validator_;
   };
 
 }  // namespace kagome::parachain