ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-06-03 00:36:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

renaming and namespace updates

Browse Source 
Signed-off-by: Pratik Mankawde <3397372+pratikmankawde@users.noreply.github.com>
This commit is contained in:
Pratik Mankawde
2026-05-28 17:52:17 +01:00
parent 23387f6a06
commit 5700eeed1b
7 changed files with 128 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
OpenTelemetryPlan/Phase4_taskList.md
View File

@@ -445,8 +445,8 @@ direct method calls, which is cleaner and avoids macro control-flow issues.
// Actual usage in Consensus.h::updateOurPositions():
span.addEvent(
"dispute.resolve",
{{cons_span::attr::txId, to_string(txId)},
{cons_span::attr::disputeOurVote, dispute.getOurVote() ? "yes" : "no"}});
{{consensus::span::attr::txId, to_string(txId)},
{consensus::span::attr::disputeOurVote, dispute.getOurVote() ? "yes" : "no"}});
```
2. **Span link support** — implemented via `SpanGuard::linkedSpan()` static factory
@@ -624,10 +624,10 @@ details.
```cpp
span.addEvent(
"dispute.resolve",
{{cons_span::attr::txId, to_string(txId)},
{cons_span::attr::disputeOurVote, dispute.getOurVote() ? "yes" : "no"},
{cons_span::attr::disputeYays, std::to_string(dispute.getYays())},
{cons_span::attr::disputeNays, std::to_string(dispute.getNays())}});
{{consensus::span::attr::txId, to_string(txId)},
{consensus::span::attr::disputeOurVote, dispute.getOurVote() ? "yes" : "no"},
{consensus::span::attr::disputeYays, std::to_string(dispute.getYays())},
{consensus::span::attr::disputeNays, std::to_string(dispute.getNays())}});
```
**Not implemented**:
@@ -687,8 +687,8 @@ wrongLedger, switchedLedger).
```cpp
auto span = telemetry::SpanGuard::span(
telemetry::TraceCategory::Consensus, telemetry::seg::consensus, "mode_change");
span.setAttribute(cons_span::attr::modeOld, to_string(before).c_str()); // "mode_old"
span.setAttribute(cons_span::attr::modeNew, to_string(after).c_str()); // "mode_new"
span.setAttribute(consensus::span::attr::modeOld, to_string(before).c_str()); // "mode_old"
span.setAttribute(consensus::span::attr::modeNew, to_string(after).c_str()); // "mode_new"
```
- `MonitoredMode::set()` in `Consensus.h` calls `adaptor_.onModeChange(before, after)`.

19
src/libxrpl/telemetry/SpanGuard.cpp
View File

@@ -424,11 +424,24 @@ SpanGuard::addEvent(std::string_view name, std::initializer_list<EventAttribute>
{
if (!impl_)
return;
std::vector<std::pair<std::string_view, opentelemetry::common::AttributeValue>> otelAttrs;
// OTel's AddEvent template requires a key-value-iterable; a plain
// std::vector<std::pair<...>> doesn't satisfy is_key_value_iterable.
// Wrap in nostd::span over the vector's storage so the SDK accepts it.
std::vector<std::pair<opentelemetry::nostd::string_view, opentelemetry::common::AttributeValue>>
otelAttrs;
otelAttrs.reserve(attrs.size());
for (auto const& [k, v] : attrs)
otelAttrs.emplace_back(k, opentelemetry::common::AttributeValue{v});
impl_->span->AddEvent(std::string(name), otelAttrs);
{
otelAttrs.emplace_back(
opentelemetry::nostd::string_view{k.data(), k.size()},
opentelemetry::common::AttributeValue{
opentelemetry::nostd::string_view{v.data(), v.size()}});
}
impl_->span->AddEvent(
std::string(name),
opentelemetry::nostd::span<std::pair<
opentelemetry::nostd::string_view,
opentelemetry::common::AttributeValue> const>{otelAttrs.data(), otelAttrs.size()});
}
void

67
src/xrpld/app/consensus/ConsensusSpanNames.h
View File

@@ -1,67 +0,0 @@
#pragma once
/** Compile-time span name and attribute constants for consensus tracing.
*
* Used by PeerImp (overlay) and RCLConsensus (consensus) for proposal
* and validation lifecycle spans. Built on StaticStr/join() from
* SpanNames.h and follows the rule-5 underscore form for shared
* cross-span attributes (e.g. `consensus_round`, `ledger_seq`).
*
* Phase 3 introduces the receive-side surface used by PeerImp.
* Phase 4 will extend this with the proposer/validator-side spans
* (`consensus.proposal.send`, `consensus.validation.send`, round
* bookkeeping, etc.).
*
* Span hierarchy (cross-node propagation):
*
* Node A (sender) Node B (receiver)
* +----------------------------+ +-------------------------------+
* | consensus.proposal/...send | proto | consensus.proposal/...receive |
* | inject trace context | -----> | proposalReceiveSpan() / |
* | (RCLConsensus broadcast) | t_ctx | validationReceiveSpan() |
* +----------------------------+ +-------------------------------+
*/
#include <xrpl/telemetry/SpanNames.h>
namespace xrpl::telemetry::cons_span {
// ===== Span prefixes =======================================================
namespace prefix {
/// "consensus" — root prefix for consensus lifecycle spans.
inline constexpr auto consensus = seg::consensus;
/// "consensus.proposal" — proposal sub-tree.
inline constexpr auto proposal = join(consensus, makeStr("proposal"));
/// "consensus.validation" — validation sub-tree.
inline constexpr auto validation = join(consensus, makeStr("validation"));
} // namespace prefix
// ===== Span operation suffixes =============================================
namespace op {
inline constexpr auto receive = makeStr("receive");
inline constexpr auto send = makeStr("send");
} // namespace op
// ===== Full span names =====================================================
inline constexpr auto proposalReceive = join(prefix::proposal, op::receive);
inline constexpr auto validationReceive = join(prefix::validation, op::receive);
// ===== Attribute keys ======================================================
namespace attr {
/// Canonical shared constants (defined in SpanNames.h).
using ::xrpl::telemetry::attr::ledgerSeq;
/// "trusted" — bare field; whether the proposing/validating node is
/// in our UNL. Used only on consensus spans, no cross-domain collision.
inline constexpr auto trusted = makeStr("trusted");
/// "consensus_round" — propose-sequence within a consensus round
/// (rule-5 underscore form, shared across consensus spans).
inline constexpr auto round = makeStr("consensus_round");
} // namespace attr
} // namespace xrpl::telemetry::cons_span

107
src/xrpld/app/consensus/RCLConsensus.cpp
View File

@@ -237,9 +237,9 @@ RCLConsensus::Adaptor::propose(RCLCxPeerPos::Proposal const& proposal)
auto span = telemetry::SpanGuard::span(
telemetry::TraceCategory::Consensus,
telemetry::seg::consensus,
telemetry::cons_span::op::proposalSend);
telemetry::consensus::span::op::proposalSend);
span.setAttribute(
telemetry::cons_span::attr::round, static_cast<int64_t>(proposal.proposeSeq()));
telemetry::consensus::span::attr::round, static_cast<int64_t>(proposal.proposeSeq()));
JLOG(j_.trace()) << (proposal.isBowOut() ? "We bow out: " : "We propose: ")
<< xrpl::to_string(proposal.prevLedger()) << " -> "
@@ -353,14 +353,12 @@ RCLConsensus::Adaptor::onClose(
NetClock::time_point const& closeTime,
ConsensusMode mode) -> Result
{
namespace cs = telemetry::consensus::span;
auto span = telemetry::SpanGuard::span(
telemetry::TraceCategory::Consensus,
telemetry::seg::consensus,
telemetry::cons_span::op::ledgerClose);
span.setAttribute(
telemetry::cons_span::attr::ledgerSeq,
static_cast<int64_t>(ledger.ledger_->header().seq) + 1);
span.setAttribute(telemetry::cons_span::attr::mode, toDisplayString(mode).c_str());
telemetry::TraceCategory::Consensus, telemetry::seg::consensus, cs::op::ledgerClose);
span.setAttribute(cs::attr::ledgerSeq, static_cast<int64_t>(ledger.ledger_->header().seq) + 1);
span.setAttribute(cs::attr::mode, toDisplayString(mode).c_str());
bool const wrongLCL = mode == ConsensusMode::wrongLedger;
bool const proposing = mode == ConsensusMode::proposing;
@@ -506,15 +504,14 @@ RCLConsensus::Adaptor::onAccept(
std::shared_ptr<telemetry::SpanGuard>
RCLConsensus::Adaptor::makeAcceptSpan(Result const& result)
{
namespace cs = telemetry::consensus::span;
auto span = std::make_shared<telemetry::SpanGuard>(
telemetry::SpanGuard::childSpan(telemetry::cons_span::accept, roundSpanContext_));
telemetry::SpanGuard::childSpan(cs::accept, roundSpanContext_));
span->setAttribute(cs::attr::proposers, static_cast<int64_t>(result.proposers));
span->setAttribute(
telemetry::cons_span::attr::proposers, static_cast<int64_t>(result.proposers));
span->setAttribute(
telemetry::cons_span::attr::roundTimeMs,
static_cast<int64_t>(result.roundTime.read().count()));
span->setAttribute(
telemetry::cons_span::attr::quorum, static_cast<int64_t>(app_.getValidators().quorum()));
cs::attr::roundTimeMs, static_cast<int64_t>(result.roundTime.read().count()));
span->setAttribute(cs::attr::quorum, static_cast<int64_t>(app_.getValidators().quorum()));
return span;
}
@@ -528,6 +525,8 @@ RCLConsensus::Adaptor::doAccept(
Json::Value&& consensusJson,
std::shared_ptr<telemetry::SpanGuard> acceptSpan)
{
namespace cs = telemetry::consensus::span;
prevProposers_ = result.proposers;
prevRoundTime_ = result.roundTime.read();
@@ -555,34 +554,29 @@ RCLConsensus::Adaptor::doAccept(
}
auto doAcceptSpan = acceptSpan
? acceptSpan->childSpan(telemetry::cons_span::acceptApply)
: telemetry::SpanGuard::childSpan(telemetry::cons_span::acceptApply, roundSpanContext_);
? acceptSpan->childSpan(cs::acceptApply)
: telemetry::SpanGuard::childSpan(cs::acceptApply, roundSpanContext_);
doAcceptSpan.setAttribute(cs::attr::ledgerSeq, static_cast<int64_t>(prevLedger.seq()) + 1);
doAcceptSpan.setAttribute(
telemetry::cons_span::attr::ledgerSeq, static_cast<int64_t>(prevLedger.seq()) + 1);
cs::attr::closeTime, static_cast<int64_t>(consensusCloseTime.time_since_epoch().count()));
doAcceptSpan.setAttribute(cs::attr::closeTimeCorrect, closeTimeCorrect);
doAcceptSpan.setAttribute(
telemetry::cons_span::attr::closeTime,
static_cast<int64_t>(consensusCloseTime.time_since_epoch().count()));
doAcceptSpan.setAttribute(telemetry::cons_span::attr::closeTimeCorrect, closeTimeCorrect);
doAcceptSpan.setAttribute(
telemetry::cons_span::attr::closeResolutionMs,
cs::attr::closeResolutionMs,
static_cast<int64_t>(
std::chrono::duration_cast<std::chrono::milliseconds>(closeResolution).count()));
doAcceptSpan.setAttribute(
telemetry::cons_span::attr::consensusState,
std::string(consensusFail ? "moved_on" : "finished"));
doAcceptSpan.setAttribute(telemetry::cons_span::attr::proposing, proposing);
cs::attr::consensusState, std::string(consensusFail ? "moved_on" : "finished"));
doAcceptSpan.setAttribute(cs::attr::proposing, proposing);
doAcceptSpan.setAttribute(
telemetry::cons_span::attr::roundTimeMs,
static_cast<int64_t>(result.roundTime.read().count()));
cs::attr::roundTimeMs, static_cast<int64_t>(result.roundTime.read().count()));
doAcceptSpan.setAttribute(
telemetry::cons_span::attr::parentCloseTime,
cs::attr::parentCloseTime,
static_cast<int64_t>(prevLedger.closeTime().time_since_epoch().count()));
doAcceptSpan.setAttribute(
telemetry::cons_span::attr::closeTimeSelf,
cs::attr::closeTimeSelf,
static_cast<int64_t>(rawCloseTimes.self.time_since_epoch().count()));
doAcceptSpan.setAttribute(
telemetry::cons_span::attr::closeTimeVoteBins,
static_cast<int64_t>(rawCloseTimes.peers.size()));
cs::attr::closeTimeVoteBins, static_cast<int64_t>(rawCloseTimes.peers.size()));
{
auto const prevRes = prevLedger.closeTimeResolution();
auto const dir = [&]() -> std::string {
@@ -596,7 +590,7 @@ RCLConsensus::Adaptor::doAccept(
}
return "unchanged";
}();
doAcceptSpan.setAttribute(telemetry::cons_span::attr::resolutionDirection, std::move(dir));
doAcceptSpan.setAttribute(cs::attr::resolutionDirection, std::move(dir));
}
JLOG(j_.debug()) << "Report: Prop=" << (proposing ? "yes" : "no")
@@ -625,9 +619,7 @@ RCLConsensus::Adaptor::doAccept(
JLOG(j_.debug()) << " Tx: " << item.key();
++txCount;
auto const txHash = to_string(item.key());
doAcceptSpan.addEvent(
telemetry::cons_span::event::txIncluded,
{{telemetry::cons_span::attr::txId, txHash}});
doAcceptSpan.addEvent(cs::event::txIncluded, {{cs::attr::txId, txHash}});
}
catch (std::exception const& ex)
{
@@ -635,7 +627,7 @@ RCLConsensus::Adaptor::doAccept(
JLOG(j_.warn()) << " Tx: " << item.key() << " throws: " << ex.what();
}
}
doAcceptSpan.setAttribute(telemetry::cons_span::attr::txCount, txCount);
doAcceptSpan.setAttribute(cs::attr::txCount, txCount);
auto built = buildLCL(
prevLedger,
@@ -927,8 +919,8 @@ RCLConsensus::Adaptor::validate(RCLCxLedger const& ledger, RCLTxSet const& txns,
if (valSpan)
{
valSpan->setAttribute(
telemetry::cons_span::attr::ledgerSeq, static_cast<int64_t>(ledger.seq()));
valSpan->setAttribute(telemetry::cons_span::attr::proposing, proposing);
telemetry::consensus::span::attr::ledgerSeq, static_cast<int64_t>(ledger.seq()));
valSpan->setAttribute(telemetry::consensus::span::attr::proposing, proposing);
}
using namespace std::chrono_literals;
@@ -1035,12 +1027,12 @@ RCLConsensus::Adaptor::validate(RCLCxLedger const& ledger, RCLTxSet const& txns,
void
RCLConsensus::Adaptor::onModeChange(ConsensusMode before, ConsensusMode after)
{
namespace cs = telemetry::consensus::span;
auto span = telemetry::SpanGuard::span(
telemetry::TraceCategory::Consensus,
telemetry::seg::consensus,
telemetry::cons_span::op::modeChange);
span.setAttribute(telemetry::cons_span::attr::modeOld, toDisplayString(before).c_str());
span.setAttribute(telemetry::cons_span::attr::modeNew, toDisplayString(after).c_str());
telemetry::TraceCategory::Consensus, telemetry::seg::consensus, cs::op::modeChange);
span.setAttribute(cs::attr::modeOld, toDisplayString(before).c_str());
span.setAttribute(cs::attr::modeNew, toDisplayString(after).c_str());
JLOG(j_.info()) << "Consensus mode change before=" << to_string(before)
<< ", after=" << to_string(after);
@@ -1212,7 +1204,7 @@ RCLConsensus::Adaptor::updateOperatingMode(std::size_t const positions) const
void
RCLConsensus::Adaptor::startRoundTracing(RCLCxLedger const& prevLgr)
{
using namespace telemetry;
namespace cs = telemetry::consensus::span;
if (roundSpan_)
roundSpan_.reset();
@@ -1222,26 +1214,27 @@ RCLConsensus::Adaptor::startRoundTracing(RCLCxLedger const& prevLgr)
if (strategy == "deterministic")
{
roundSpan_.emplace(
SpanGuard::hashSpan(
TraceCategory::Consensus,
cons_span::round,
telemetry::SpanGuard::hashSpan(
telemetry::TraceCategory::Consensus,
cs::round,
prevLgr.id().data(),
prevLgr.id().bytes));
}
else
{
roundSpan_.emplace(
SpanGuard::span(TraceCategory::Consensus, seg::consensus, cons_span::op::round));
telemetry::SpanGuard::span(
telemetry::TraceCategory::Consensus, telemetry::seg::consensus, cs::op::round));
}
if (!*roundSpan_)
return;
roundSpan_->setAttribute(cons_span::attr::ledgerId, to_string(prevLgr.id()).c_str());
roundSpan_->setAttribute(cons_span::attr::ledgerSeq, static_cast<int64_t>(prevLgr.seq()) + 1);
roundSpan_->setAttribute(cons_span::attr::mode, toDisplayString(mode_.load()).c_str());
roundSpan_->setAttribute(cons_span::attr::traceStrategy, strategy.c_str());
roundSpan_->setAttribute(cons_span::attr::roundId, static_cast<int64_t>(prevLgr.seq()) + 1);
roundSpan_->setAttribute(cs::attr::ledgerId, to_string(prevLgr.id()).c_str());
roundSpan_->setAttribute(cs::attr::ledgerSeq, static_cast<int64_t>(prevLgr.seq()) + 1);
roundSpan_->setAttribute(cs::attr::mode, toDisplayString(mode_.load()).c_str());
roundSpan_->setAttribute(cs::attr::traceStrategy, strategy.c_str());
roundSpan_->setAttribute(cs::attr::roundId, static_cast<int64_t>(prevLgr.seq()) + 1);
roundSpanContext_ = roundSpan_->captureContext();
}
@@ -1249,12 +1242,12 @@ RCLConsensus::Adaptor::startRoundTracing(RCLCxLedger const& prevLgr)
std::optional<telemetry::SpanGuard>
RCLConsensus::Adaptor::createValidationSpan()
{
using namespace telemetry;
namespace cs = telemetry::consensus::span;
if (!roundSpanContext_.isValid())
return std::nullopt;
return SpanGuard::linkedSpan(cons_span::validationSend, roundSpanContext_);
return telemetry::SpanGuard::linkedSpan(cs::validationSend, roundSpanContext_);
}
void

56
src/xrpld/consensus/Consensus.h
View File

@@ -704,7 +704,7 @@ Consensus<Adaptor>::startRoundInternal(
telemetry::SpanGuard::span(
telemetry::TraceCategory::Consensus,
telemetry::seg::consensus,
telemetry::cons_span::op::phaseOpen));
telemetry::consensus::span::op::phaseOpen));
mode_.set(mode, adaptor_);
now_ = now;
prevLedgerID_ = prevLedgerID;
@@ -1488,12 +1488,14 @@ Consensus<Adaptor>::updateOurPositions(std::unique_ptr<std::stringstream> const&
XRPL_ASSERT(result_, "xrpl::Consensus::updateOurPositions : result is set");
// NOLINTBEGIN(bugprone-unchecked-optional-access) assert above
using namespace telemetry;
auto span =
SpanGuard::span(TraceCategory::Consensus, seg::consensus, cons_span::op::updatePositions);
span.setAttribute(cons_span::attr::convergePercent, static_cast<int64_t>(convergePercent_));
span.setAttribute(cons_span::attr::proposers, static_cast<int64_t>(currPeerPositions_.size()));
auto span = SpanGuard::span(
TraceCategory::Consensus, seg::consensus, consensus::span::op::updatePositions);
span.setAttribute(
cons_span::attr::disputesCount, static_cast<int64_t>(result_->disputes.size()));
consensus::span::attr::convergePercent, static_cast<int64_t>(convergePercent_));
span.setAttribute(
consensus::span::attr::proposers, static_cast<int64_t>(currPeerPositions_.size()));
span.setAttribute(
consensus::span::attr::disputesCount, static_cast<int64_t>(result_->disputes.size()));
ConsensusParms const& parms = adaptor_.parms();
// Compute a cutoff time
@@ -1557,11 +1559,11 @@ Consensus<Adaptor>::updateOurPositions(std::unique_ptr<std::stringstream> const&
auto const yaysStr = std::to_string(dispute.getYays());
auto const naysStr = std::to_string(dispute.getNays());
span.addEvent(
cons_span::event::disputeResolve,
{{cons_span::attr::txId, to_string(txId)},
{cons_span::attr::disputeOurVote, dispute.getOurVote() ? "yes" : "no"},
{cons_span::attr::disputeYays, yaysStr},
{cons_span::attr::disputeNays, naysStr}});
consensus::span::event::disputeResolve,
{{consensus::span::attr::txId, to_string(txId)},
{consensus::span::attr::disputeOurVote, dispute.getOurVote() ? "yes" : "no"},
{consensus::span::attr::disputeYays, yaysStr},
{consensus::span::attr::disputeNays, naysStr}});
}
}
@@ -1586,7 +1588,8 @@ Consensus<Adaptor>::updateOurPositions(std::unique_ptr<std::stringstream> const&
if (newState)
closeTimeAvalancheState_ = *newState;
CLOG(clog) << "neededWeight " << neededWeight << ". ";
span.setAttribute(cons_span::attr::avalancheThreshold, static_cast<int64_t>(neededWeight));
span.setAttribute(
consensus::span::attr::avalancheThreshold, static_cast<int64_t>(neededWeight));
int participants = currPeerPositions_.size();
if (mode_.get() == ConsensusMode::proposing)
@@ -1635,9 +1638,9 @@ Consensus<Adaptor>::updateOurPositions(std::unique_ptr<std::stringstream> const&
}
}
span.setAttribute(cons_span::attr::haveCloseTimeConsensus, haveCloseTimeConsensus_);
span.setAttribute(consensus::span::attr::haveCloseTimeConsensus, haveCloseTimeConsensus_);
span.setAttribute(
cons_span::attr::closeTimeThreshold, static_cast<int64_t>(parms.avCT_CONSENSUS_PCT));
consensus::span::attr::closeTimeThreshold, static_cast<int64_t>(parms.avCT_CONSENSUS_PCT));
if (!ourNewSet &&
((consensusCloseTime != asCloseTime(result_->position.closeTime())) ||
@@ -1691,7 +1694,8 @@ Consensus<Adaptor>::haveConsensus(std::unique_ptr<std::stringstream> const& clog
XRPL_ASSERT(result_, "xrpl::Consensus::haveConsensus : has result");
// NOLINTBEGIN(bugprone-unchecked-optional-access) assert above
using namespace telemetry;
auto span = SpanGuard::span(TraceCategory::Consensus, seg::consensus, cons_span::op::check);
auto span =
SpanGuard::span(TraceCategory::Consensus, seg::consensus, consensus::span::op::check);
// CHECKME: should possibly count unacquired TX sets as disagreeing
int agree = 0, disagree = 0;
@@ -1791,12 +1795,13 @@ Consensus<Adaptor>::haveConsensus(std::unique_ptr<std::stringstream> const& clog
CLOG(clog) << "Unable to reach consensus " << Json::Compact{getJson(true)} << ". ";
}
span.setAttribute(cons_span::attr::agreeCount, static_cast<int64_t>(agree));
span.setAttribute(cons_span::attr::disagreeCount, static_cast<int64_t>(disagree));
span.setAttribute(cons_span::attr::convergePercent, static_cast<int64_t>(convergePercent_));
span.setAttribute(cons_span::attr::haveCloseTimeConsensus, haveCloseTimeConsensus_);
span.setAttribute(consensus::span::attr::agreeCount, static_cast<int64_t>(agree));
span.setAttribute(consensus::span::attr::disagreeCount, static_cast<int64_t>(disagree));
span.setAttribute(
cons_span::attr::thresholdPercent,
consensus::span::attr::convergePercent, static_cast<int64_t>(convergePercent_));
span.setAttribute(consensus::span::attr::haveCloseTimeConsensus, haveCloseTimeConsensus_);
span.setAttribute(
consensus::span::attr::thresholdPercent,
static_cast<int64_t>(adaptor_.parms().avCT_CONSENSUS_PCT));
char const* stateStr = "no";
@@ -1812,7 +1817,7 @@ Consensus<Adaptor>::haveConsensus(std::unique_ptr<std::stringstream> const& clog
{
stateStr = "expired";
}
span.setAttribute(cons_span::attr::consensusResult, stateStr);
span.setAttribute(consensus::span::attr::consensusResult, stateStr);
CLOG(clog) << "Consensus has been reached. ";
// NOLINTEND(bugprone-unchecked-optional-access)
@@ -1945,7 +1950,7 @@ Consensus<Adaptor>::startEstablishTracing()
telemetry::SpanGuard::span(
telemetry::TraceCategory::Consensus,
telemetry::seg::consensus,
telemetry::cons_span::op::establish));
telemetry::consensus::span::op::establish));
}
template <class Adaptor>
@@ -1955,11 +1960,12 @@ Consensus<Adaptor>::updateEstablishTracing()
if (!establishSpan_)
return;
establishSpan_->setAttribute(
telemetry::cons_span::attr::convergePercent, static_cast<int64_t>(convergePercent_));
telemetry::consensus::span::attr::convergePercent, static_cast<int64_t>(convergePercent_));
establishSpan_->setAttribute(
telemetry::cons_span::attr::establishCount, static_cast<int64_t>(establishCounter_));
telemetry::consensus::span::attr::establishCount, static_cast<int64_t>(establishCounter_));
establishSpan_->setAttribute(
telemetry::cons_span::attr::proposers, static_cast<int64_t>(currPeerPositions_.size()));
telemetry::consensus::span::attr::proposers,
static_cast<int64_t>(currPeerPositions_.size()));
}
template <class Adaptor>

34
src/xrpld/consensus/ConsensusSpanNames.h
View File

@@ -14,7 +14,8 @@
*
* consensus.round [main thread, root]
* | Created: Adaptor::startRoundTracing()
* | Attrs: ledger_id, ledger.seq, mode, trace_strategy, round_id
* | Attrs: consensus_ledger_id, ledger_seq, consensus_mode,
* | trace_strategy, consensus_round_id
* |
* +-- consensus.phase.open [main thread, child]
* | Created: Consensus::startRoundInternal()
@@ -22,11 +23,11 @@
* |
* +-- consensus.proposal.send [main thread]
* | Created: Adaptor::propose()
* | Attrs: round (proposeSeq)
* | Attrs: consensus_round (proposeSeq)
* |
* +-- consensus.ledger_close [main thread]
* | Created: Adaptor::onClose()
* | Attrs: ledger.seq, mode
* | Attrs: ledger_seq, consensus_mode
* |
* +-- consensus.establish [main thread, child]
* | Created: Consensus::startEstablishTracing()
@@ -49,19 +50,19 @@
* | |
* | +-- consensus.accept.apply [jtACCEPT thread, child of accept]
* | Created: Adaptor::doAccept()
* | Attrs: ledger.seq, close_time, close_time_correct,
* | close_resolution_ms, state, proposing, round_time_ms,
* | Attrs: ledger_seq, close_time, close_time_correct,
* | close_resolution_ms, consensus_state, proposing, round_time_ms,
* | parent_close_time, close_time_self, close_time_vote_bins,
* | resolution_direction, tx_count
* | Events: tx.included (per tx)
* | Events: tx.included (per tx, attrs: tx_id)
* |
* +~~~ consensus.validation.send [jtACCEPT thread, linked]
* | Created: Adaptor::createValidationSpan() (follows-from link)
* | Attrs: ledger.seq, proposing
* | Attrs: ledger_seq, proposing
* |
* +-- consensus.mode_change [main thread]
* Created: Adaptor::onModeChange()
* Attrs: mode.old, mode.new
* Attrs: mode_old, mode_new
*
* Standalone spans (no parent, created per-message in overlay):
*
@@ -78,7 +79,7 @@
#include <xrpl/telemetry/SpanNames.h>
namespace xrpl::telemetry::cons_span {
namespace xrpl::telemetry::consensus::span {
// ===== Span name segments ====================================================
@@ -130,11 +131,12 @@ using ::xrpl::telemetry::attr::closeTime;
using ::xrpl::telemetry::attr::closeTimeCorrect;
using ::xrpl::telemetry::attr::ledgerSeq;
/// Kept qualified (rule 5 — bare name ambiguous across domains).
inline constexpr auto ledgerId = join(join(seg::xrpl, seg::consensus), makeStr("ledger_id"));
inline constexpr auto mode = join(join(seg::xrpl, seg::consensus), makeStr("mode"));
inline constexpr auto round = join(join(seg::xrpl, seg::consensus), makeStr("round"));
inline constexpr auto roundId = join(join(seg::xrpl, seg::consensus), makeStr("round_id"));
/// Domain-qualified attrs (rule 5 — bare name ambiguous across domains).
/// Use `<domain>_<field>` underscore form for TraceQL ergonomics.
inline constexpr auto ledgerId = makeStr("consensus_ledger_id");
inline constexpr auto mode = makeStr("consensus_mode");
inline constexpr auto round = makeStr("consensus_round");
inline constexpr auto roundId = makeStr("consensus_round_id");
/// Domain-owned bare attrs.
inline constexpr auto proposers = makeStr("proposers");
@@ -162,7 +164,7 @@ inline constexpr auto modeOld = makeStr("mode_old");
inline constexpr auto modeNew = makeStr("mode_new");
/// Transaction/dispute attrs used in consensus accept spans.
inline constexpr auto txId = join(join(seg::xrpl, seg::tx), makeStr("id"));
inline constexpr auto txId = makeStr("tx_id");
inline constexpr auto disputeOurVote = makeStr("dispute_our_vote");
inline constexpr auto disputeYays = makeStr("dispute_yays");
inline constexpr auto disputeNays = makeStr("dispute_nays");
@@ -193,4 +195,4 @@ inline constexpr auto decreased = makeStr("decreased");
inline constexpr auto unchanged = makeStr("unchanged");
} // namespace val
} // namespace xrpl::telemetry::cons_span
} // namespace xrpl::telemetry::consensus::span

10
src/xrpld/overlay/detail/PeerImp.cpp
View File

@@ -1,6 +1,5 @@
#include <xrpld/overlay/detail/PeerImp.h>
#include <xrpld/app/consensus/ConsensusSpanNames.h>
#include <xrpld/app/consensus/RCLCxPeerPos.h>
#include <xrpld/app/consensus/RCLValidations.h>
#include <xrpld/app/ledger/InboundLedgers.h>
@@ -1980,8 +1979,9 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMProposeSet> const& m)
// Create a receive span that links to the sender's trace context
// (if propagated). shared_ptr keeps it alive across the job boundary.
auto span = std::make_shared<telemetry::SpanGuard>(telemetry::proposalReceiveSpan(set));
span->setAttribute(telemetry::cons_span::attr::trusted, isTrusted);
span->setAttribute(telemetry::cons_span::attr::round, static_cast<int64_t>(set.proposeseq()));
span->setAttribute(telemetry::consensus::span::attr::trusted, isTrusted);
span->setAttribute(
telemetry::consensus::span::attr::round, static_cast<int64_t>(set.proposeseq()));
std::weak_ptr<PeerImp> const weak = shared_from_this();
app_.getJobQueue().addJob(
@@ -2565,11 +2565,11 @@ PeerImp::onMessage(std::shared_ptr<protocol::TMValidation> const& m)
// Create a receive span that links to the sender's trace context
// (if propagated). shared_ptr keeps it alive across the job boundary.
auto span = std::make_shared<telemetry::SpanGuard>(telemetry::validationReceiveSpan(*m));
span->setAttribute(telemetry::cons_span::attr::trusted, isTrusted);
span->setAttribute(telemetry::consensus::span::attr::trusted, isTrusted);
if (val->isFieldPresent(sfLedgerSequence))
{
span->setAttribute(
telemetry::cons_span::attr::ledgerSeq,
telemetry::consensus::span::attr::ledgerSeq,
static_cast<int64_t>(val->getFieldU32(sfLedgerSequence)));
}