Send blocks telemetry immediately or in 1 sec intervals

core/blockchain/impl/block_tree_impl.cpp

@@ -904,6 +904,7 @@ namespace kagome::blockchain {
 
         log_->info("Finalized block {}", block);
         telemetry_->notifyBlockFinalized(block);
+        telemetry_->pushBlockStats();
         metric_finalized_block_height_->set(node->depth);
 
       } else if (node->block_hash == last_finalized_block_info.hash) {
@@ -1589,6 +1590,7 @@ namespace kagome::blockchain {
     metric_known_chain_leaves_->set(leaves_size);
     metric_best_block_height_->set(block_info.number);
     telemetry_->notifyBlockFinalized(block_info);
+    telemetry_->pushBlockStats();
     metric_finalized_block_height_->set(block_info.number);
   }
 

core/consensus/babe/impl/babe.cpp

@@ -544,6 +544,7 @@ namespace kagome::consensus::babe {
         block_info.hash, storage_sub_engine_, chain_sub_engine_);
 
     telemetry_->notifyBlockImported(block_info, telemetry::BlockOrigin::kOwn);
+    telemetry_->pushBlockStats();
 
     // observe digest of block
     // (must be done strictly after block will be added)

core/consensus/timeline/impl/block_executor_impl.cpp

@@ -289,6 +289,7 @@ namespace kagome::consensus {
           auto current_best_block = self->block_tree_->bestBlock();
           self->telemetry_->notifyBlockImported(
               current_best_block, telemetry::BlockOrigin::kNetworkInitialSync);
+          self->telemetry_->pushBlockStats();
 
           // Create new offchain worker for block if it is best only
           if (current_best_block.number > previous_best_block_number) {

core/telemetry/impl/service_impl.cpp

@@ -319,6 +319,10 @@ namespace kagome::telemetry {
     }
   }
 
+  void TelemetryServiceImpl::pushBlockStats() {
+    frequentNotificationsRoutine();
+  }
+
   std::string TelemetryServiceImpl::blockNotification(
       const primitives::BlockInfo &info, std::optional<BlockOrigin> origin) {
     std::string event_name =

core/telemetry/impl/service_impl.hpp

@@ -65,6 +65,8 @@ namespace kagome::telemetry {
 
     void notifyBlockFinalized(const primitives::BlockInfo &info) override;
 
+    void pushBlockStats() override;
+
     void setGenesisBlockHash(const primitives::BlockHash &hash) override;
 
     void notifyWasSynchronized() override;

core/telemetry/service.cpp

@@ -30,6 +30,11 @@ namespace kagome::telemetry {
           service_->notifyBlockFinalized(info);
         }
       }
+      void pushBlockStats() override {
+        if (service_) {
+          service_->pushBlockStats();
+        }
+      }
       void notifyWasSynchronized() override {
         if (service_) {
           service_->notifyWasSynchronized();

core/telemetry/service.hpp

@@ -76,6 +76,11 @@ namespace kagome::telemetry {
      */
     virtual void notifyBlockFinalized(const primitives::BlockInfo &info) = 0;
 
+    /**
+     * Send imported+finalized blocks info immediately and reset periodic timer
+     */
+    virtual void pushBlockStats() = 0;
+
     /**
      * Telemetry service status
      * @return true - when application configured to broadcast telemetry

test/mock/core/telemetry/telemetry_service_mock.hpp

@@ -28,6 +28,11 @@ namespace kagome::telemetry {
                 (const primitives::BlockInfo &),
                 (override));
 
+    MOCK_METHOD(void,
+                pushBlockStats,
+                (),
+                (override));
+
     MOCK_METHOD(void, notifyWasSynchronized, (), (override));
 
     MOCK_METHOD(bool, isEnabled, (), (const override));