Merge 7bbbc15db0 into dd96032e12

src/evo/deterministicmns.cpp

@@ -21,6 +21,7 @@
 #include <univalue.h>
 #include <messagesigner.h>
 #include <uint256.h>
+#include <stats/client.h>
 
 #include <optional>
 #include <memory>
@@ -645,6 +646,17 @@ bool CDeterministicMNManager::ProcessBlock(const CBlock& block, gsl::not_null<co
         updatesRet = {newList, oldList, diff};
     }
 
+    if (::g_stats_client->active()) {
+        ::g_stats_client->gauge("masternodes.count", newList.GetAllMNsCount());
+        ::g_stats_client->gauge("masternodes.weighted_count", newList.GetValidWeightedMNsCount());
+        ::g_stats_client->gauge("masternodes.enabled", newList.GetValidMNsCount());
+        ::g_stats_client->gauge("masternodes.weighted_enabled", newList.GetValidWeightedMNsCount());
+        ::g_stats_client->gauge("masternodes.evo.count", newList.GetAllEvoCount());
+        ::g_stats_client->gauge("masternodes.evo.enabled", newList.GetValidEvoCount());
+        ::g_stats_client->gauge("masternodes.mn.count", newList.GetAllMNsCount() - newList.GetAllEvoCount());
+        ::g_stats_client->gauge("masternodes.mn.enabled", newList.GetValidMNsCount() - newList.GetValidEvoCount());
+    }
+
     if (nHeight == consensusParams.DIP0003EnforcementHeight) {
         if (!consensusParams.DIP0003EnforcementHash.IsNull() && consensusParams.DIP0003EnforcementHash != pindex->GetBlockHash()) {
             LogPrintf("CDeterministicMNManager::%s -- DIP3 enforcement block has wrong hash: hash=%s, expected=%s, nHeight=%d\n", __func__,

src/init.cpp

@@ -828,6 +828,7 @@ static void PeriodicStats(NodeContext& node)
     const ArgsManager& args = *Assert(node.args);
     ChainstateManager& chainman = *Assert(node.chainman);
     const CTxMemPool& mempool = *Assert(node.mempool);
+    const llmq::CInstantSendManager& isman = *Assert(node.llmq_ctx->isman);
     CCoinsStats stats{CoinStatsHashType::NONE};
     chainman.ActiveChainstate().ForceFlushStateToDisk();
     if (WITH_LOCK(cs_main, return GetUTXOStats(&chainman.ActiveChainstate().CoinsDB(), chainman.m_blockman, stats, node.rpc_interruption_point, chainman.ActiveChain().Tip()))) {
@@ -880,6 +881,7 @@ static void PeriodicStats(NodeContext& node)
         ::g_stats_client->gauge("transactions.mempool.memoryUsageBytes", (int64_t) mempool.DynamicMemoryUsage(), 1.0f);
         ::g_stats_client->gauge("transactions.mempool.minFeePerKb", mempool.GetMinFee(args.GetArg("-maxmempool", DEFAULT_MAX_MEMPOOL_SIZE) * 1000000).GetFeePerK(), 1.0f);
     }
+    ::g_stats_client->gauge("transactions.mempool.lockedTransactions", isman.GetInstantSendLockCount(), 1.0f);
 }
 
 static bool AppInitServers(NodeContext& node)

src/llmq/chainlocks.cpp

@@ -15,6 +15,7 @@
 #include <node/interface_ui.h>
 #include <scheduler.h>
 #include <spork.h>
+#include <stats/client.h>
 #include <txmempool.h>
 #include <util/thread.h>
 #include <util/time.h>
@@ -499,6 +500,7 @@ void CChainLocksHandler::EnforceBestChainLock()
 
     GetMainSignals().NotifyChainLock(currentBestChainLockBlockIndex, clsig);
     uiInterface.NotifyChainLock(clsig->getBlockHash().ToString(), clsig->getHeight());
+    ::g_stats_client->gauge("chainlocks.blockHeight", clsig->getHeight(), 1.0f);
 }
 
 MessageProcessingResult CChainLocksHandler::HandleNewRecoveredSig(const llmq::CRecoveredSig& recoveredSig)

src/llmq/instantsend.cpp

@@ -23,6 +23,7 @@
 #include <util/ranges.h>
 #include <util/thread.h>
 #include <validation.h>
+#include <stats/client.h>
 
 #include <cxxtimer.hpp>
 
@@ -776,6 +777,17 @@ PeerMsgRet CInstantSendManager::ProcessMessageInstantSendLock(const CNode& pfrom
     LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, islock=%s: received islock, peer=%d\n", __func__,
             islock->txid.ToString(), hash.ToString(), pfrom.GetId());
 
+    auto time_diff =  [&] () -> int64_t {
+        LOCK(cs_timingsTxSeen);
+        if (auto it = timingsTxSeen.find(islock->txid); it != timingsTxSeen.end()) {
+            // This is the normal case where we received the TX before the islock
+            return GetTimeMillis() - it->second;
+        }
+        // But if we received the islock and don't know when we got the tx, then say 0, to indicate we received the islock first.
+        return 0;
+    }();
+    ::g_stats_client->timing("islock_ms", time_diff);
+
     LOCK(cs_pendingLocks);
     pendingInstantSendLocks.emplace(hash, std::make_pair(pfrom.GetId(), islock));
     return {};
@@ -1169,6 +1181,15 @@ void CInstantSendManager::AddNonLockedTx(const CTransactionRef& tx, const CBlock
             ++it;
         }
     }
+
+    {
+        LOCK(cs_timingsTxSeen);
+        // Only insert the time the first time we see the tx, as we sometimes try to resign
+        if (auto it = timingsTxSeen.find(tx->GetHash()); it == timingsTxSeen.end()) {
+            timingsTxSeen[tx->GetHash()] = GetTimeMillis();
+        }
+    }
+
     LogPrint(BCLog::INSTANTSEND, "CInstantSendManager::%s -- txid=%s, pindexMined=%s\n", __func__,
              tx->GetHash().ToString(), pindexMined ? pindexMined->GetBlockHash().ToString() : "");
 }

src/llmq/instantsend.h

@@ -252,6 +252,9 @@ private:
     mutable Mutex cs_pendingRetry;
     std::unordered_set<uint256, StaticSaltedHasher> pendingRetryTxs GUARDED_BY(cs_pendingRetry);
 
+    mutable Mutex cs_timingsTxSeen;
+    std::unordered_map<uint256, int64_t, StaticSaltedHasher> timingsTxSeen GUARDED_BY(cs_timingsTxSeen);
+
 public:
     explicit CInstantSendManager(CChainLocksHandler& _clhandler, CChainState& chainstate, CQuorumManager& _qman,
                                  CSigningManager& _sigman, CSigSharesManager& _shareman, CSporkManager& sporkman,

src/validation.cpp

@@ -2301,7 +2301,7 @@ bool CChainState::ConnectBlock(const CBlock& block, BlockValidationState& state,
 
     ::g_stats_client->timing("ConnectBlock_ms", (nTime8 - nTimeStart) / 1000, 1.0f);
     ::g_stats_client->gauge("blocks.tip.SizeBytes", ::GetSerializeSize(block, PROTOCOL_VERSION), 1.0f);
-    ::g_stats_client->gauge("blocks.tip.Height", m_chain.Height(), 1.0f);
+    ::g_stats_client->gauge("blocks.tip.Height", m_chain.Height() + 1, 1.0f); // without the +1, the "tip.Height" doesn't match rpc calls like `getblockcount`
     ::g_stats_client->gauge("blocks.tip.Version", block.nVersion, 1.0f);
     ::g_stats_client->gauge("blocks.tip.NumTransactions", block.vtx.size(), 1.0f);
     ::g_stats_client->gauge("blocks.tip.SigOps", nSigOps, 1.0f);
@@ -2623,6 +2623,8 @@ bool CChainState::DisconnectTip(BlockValidationState& state, DisconnectedBlockTr
     AssertLockHeld(cs_main);
     if (m_mempool) AssertLockHeld(m_mempool->cs);
 
+    int64_t nTime1 = GetTimeMicros();
+
     CBlockIndex *pindexDelete = m_chain.Tip();
     assert(pindexDelete);
     // Read block from disk.
@@ -2681,6 +2683,19 @@ bool CChainState::DisconnectTip(BlockValidationState& state, DisconnectedBlockTr
     // Let wallets know transactions went from 1-confirmed to
     // 0-confirmed or conflicted:
     GetMainSignals().BlockDisconnected(pblock, pindexDelete);
+
+    int64_t nTime2 = GetTimeMicros();
+
+    unsigned int nSigOps = 0;
+    for (const auto& tx : block.vtx) {
+        nSigOps += GetLegacySigOpCount(*tx);
+    }
+    ::g_stats_client->timing("DisconnectTip_ms", (nTime2 - nTime1) / 1000, 1.0f);
+    ::g_stats_client->gauge("blocks.tip.SizeBytes", ::GetSerializeSize(block, PROTOCOL_VERSION), 1.0f);
+    ::g_stats_client->gauge("blocks.tip.Height", m_chain.Height(), 1.0f);
+    ::g_stats_client->gauge("blocks.tip.Version", block.nVersion, 1.0f);
+    ::g_stats_client->gauge("blocks.tip.NumTransactions", block.vtx.size(), 1.0f);
+    ::g_stats_client->gauge("blocks.tip.SigOps", nSigOps, 1.0f);
     return true;
 }
 
@@ -2799,7 +2814,16 @@ bool CChainState::ConnectTip(BlockValidationState& state, CBlockIndex* pindexNew
     LogPrint(BCLog::BENCHMARK, "  - Connect postprocess: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime6 - nTime5) * MILLI, nTimePostConnect * MICRO, nTimePostConnect * MILLI / nBlocksTotal);
     LogPrint(BCLog::BENCHMARK, "- Connect block: %.2fms [%.2fs (%.2fms/blk)]\n", (nTime6 - nTime1) * MILLI, nTimeTotal * MICRO, nTimeTotal * MILLI / nBlocksTotal);
 
+    unsigned int nSigOps = 0;
+    for (const auto& tx : blockConnecting.vtx) {
+        nSigOps += GetLegacySigOpCount(*tx);
+    }
     ::g_stats_client->timing("ConnectTip_ms", (nTime6 - nTime1) / 1000, 1.0f);
+    ::g_stats_client->gauge("blocks.tip.SizeBytes", ::GetSerializeSize(blockConnecting, PROTOCOL_VERSION), 1.0f);
+    ::g_stats_client->gauge("blocks.tip.Height", m_chain.Height(), 1.0f);
+    ::g_stats_client->gauge("blocks.tip.Version", blockConnecting.nVersion, 1.0f);
+    ::g_stats_client->gauge("blocks.tip.NumTransactions", blockConnecting.vtx.size(), 1.0f);
+    ::g_stats_client->gauge("blocks.tip.SigOps", nSigOps, 1.0f);
 
     connectTrace.BlockConnected(pindexNew, std::move(pthisBlock));
     return true;