diff --git a/OpenTelemetryPlan/Phase4_taskList.md b/OpenTelemetryPlan/Phase4_taskList.md index 6d084c5934..4c93f7f1ee 100644 --- a/OpenTelemetryPlan/Phase4_taskList.md +++ b/OpenTelemetryPlan/Phase4_taskList.md @@ -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)`. diff --git a/src/libxrpl/telemetry/SpanGuard.cpp b/src/libxrpl/telemetry/SpanGuard.cpp index 53c6f31616..2005d61dd2 100644 --- a/src/libxrpl/telemetry/SpanGuard.cpp +++ b/src/libxrpl/telemetry/SpanGuard.cpp @@ -424,11 +424,24 @@ SpanGuard::addEvent(std::string_view name, std::initializer_list { if (!impl_) return; - std::vector> otelAttrs; + // OTel's AddEvent template requires a key-value-iterable; a plain + // std::vector> doesn't satisfy is_key_value_iterable. + // Wrap in nostd::span over the vector's storage so the SDK accepts it. + std::vector> + 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 const>{otelAttrs.data(), otelAttrs.size()}); } void diff --git a/src/xrpld/app/consensus/ConsensusSpanNames.h b/src/xrpld/app/consensus/ConsensusSpanNames.h deleted file mode 100644 index 29203eb29d..0000000000 --- a/src/xrpld/app/consensus/ConsensusSpanNames.h +++ /dev/null @@ -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 - -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 diff --git a/src/xrpld/app/consensus/RCLConsensus.cpp b/src/xrpld/app/consensus/RCLConsensus.cpp index 744ac538e8..63cf79655c 100644 --- a/src/xrpld/app/consensus/RCLConsensus.cpp +++ b/src/xrpld/app/consensus/RCLConsensus.cpp @@ -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(proposal.proposeSeq())); + telemetry::consensus::span::attr::round, static_cast(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(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(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 RCLConsensus::Adaptor::makeAcceptSpan(Result const& result) { + namespace cs = telemetry::consensus::span; + auto span = std::make_shared( - telemetry::SpanGuard::childSpan(telemetry::cons_span::accept, roundSpanContext_)); + telemetry::SpanGuard::childSpan(cs::accept, roundSpanContext_)); + span->setAttribute(cs::attr::proposers, static_cast(result.proposers)); span->setAttribute( - telemetry::cons_span::attr::proposers, static_cast(result.proposers)); - span->setAttribute( - telemetry::cons_span::attr::roundTimeMs, - static_cast(result.roundTime.read().count())); - span->setAttribute( - telemetry::cons_span::attr::quorum, static_cast(app_.getValidators().quorum())); + cs::attr::roundTimeMs, static_cast(result.roundTime.read().count())); + span->setAttribute(cs::attr::quorum, static_cast(app_.getValidators().quorum())); return span; } @@ -528,6 +525,8 @@ RCLConsensus::Adaptor::doAccept( Json::Value&& consensusJson, std::shared_ptr 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(prevLedger.seq()) + 1); doAcceptSpan.setAttribute( - telemetry::cons_span::attr::ledgerSeq, static_cast(prevLedger.seq()) + 1); + cs::attr::closeTime, static_cast(consensusCloseTime.time_since_epoch().count())); + doAcceptSpan.setAttribute(cs::attr::closeTimeCorrect, closeTimeCorrect); doAcceptSpan.setAttribute( - telemetry::cons_span::attr::closeTime, - static_cast(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( std::chrono::duration_cast(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(result.roundTime.read().count())); + cs::attr::roundTimeMs, static_cast(result.roundTime.read().count())); doAcceptSpan.setAttribute( - telemetry::cons_span::attr::parentCloseTime, + cs::attr::parentCloseTime, static_cast(prevLedger.closeTime().time_since_epoch().count())); doAcceptSpan.setAttribute( - telemetry::cons_span::attr::closeTimeSelf, + cs::attr::closeTimeSelf, static_cast(rawCloseTimes.self.time_since_epoch().count())); doAcceptSpan.setAttribute( - telemetry::cons_span::attr::closeTimeVoteBins, - static_cast(rawCloseTimes.peers.size())); + cs::attr::closeTimeVoteBins, static_cast(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(ledger.seq())); - valSpan->setAttribute(telemetry::cons_span::attr::proposing, proposing); + telemetry::consensus::span::attr::ledgerSeq, static_cast(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(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(prevLgr.seq()) + 1); + roundSpan_->setAttribute(cs::attr::ledgerId, to_string(prevLgr.id()).c_str()); + roundSpan_->setAttribute(cs::attr::ledgerSeq, static_cast(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(prevLgr.seq()) + 1); roundSpanContext_ = roundSpan_->captureContext(); } @@ -1249,12 +1242,12 @@ RCLConsensus::Adaptor::startRoundTracing(RCLCxLedger const& prevLgr) std::optional 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 diff --git a/src/xrpld/consensus/Consensus.h b/src/xrpld/consensus/Consensus.h index 3c1df2414d..25e0884a64 100644 --- a/src/xrpld/consensus/Consensus.h +++ b/src/xrpld/consensus/Consensus.h @@ -704,7 +704,7 @@ Consensus::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::updateOurPositions(std::unique_ptr 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(convergePercent_)); - span.setAttribute(cons_span::attr::proposers, static_cast(currPeerPositions_.size())); + auto span = SpanGuard::span( + TraceCategory::Consensus, seg::consensus, consensus::span::op::updatePositions); span.setAttribute( - cons_span::attr::disputesCount, static_cast(result_->disputes.size())); + consensus::span::attr::convergePercent, static_cast(convergePercent_)); + span.setAttribute( + consensus::span::attr::proposers, static_cast(currPeerPositions_.size())); + span.setAttribute( + consensus::span::attr::disputesCount, static_cast(result_->disputes.size())); ConsensusParms const& parms = adaptor_.parms(); // Compute a cutoff time @@ -1557,11 +1559,11 @@ Consensus::updateOurPositions(std::unique_ptr 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::updateOurPositions(std::unique_ptr const& if (newState) closeTimeAvalancheState_ = *newState; CLOG(clog) << "neededWeight " << neededWeight << ". "; - span.setAttribute(cons_span::attr::avalancheThreshold, static_cast(neededWeight)); + span.setAttribute( + consensus::span::attr::avalancheThreshold, static_cast(neededWeight)); int participants = currPeerPositions_.size(); if (mode_.get() == ConsensusMode::proposing) @@ -1635,9 +1638,9 @@ Consensus::updateOurPositions(std::unique_ptr const& } } - span.setAttribute(cons_span::attr::haveCloseTimeConsensus, haveCloseTimeConsensus_); + span.setAttribute(consensus::span::attr::haveCloseTimeConsensus, haveCloseTimeConsensus_); span.setAttribute( - cons_span::attr::closeTimeThreshold, static_cast(parms.avCT_CONSENSUS_PCT)); + consensus::span::attr::closeTimeThreshold, static_cast(parms.avCT_CONSENSUS_PCT)); if (!ourNewSet && ((consensusCloseTime != asCloseTime(result_->position.closeTime())) || @@ -1691,7 +1694,8 @@ Consensus::haveConsensus(std::unique_ptr 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::haveConsensus(std::unique_ptr const& clog CLOG(clog) << "Unable to reach consensus " << Json::Compact{getJson(true)} << ". "; } - span.setAttribute(cons_span::attr::agreeCount, static_cast(agree)); - span.setAttribute(cons_span::attr::disagreeCount, static_cast(disagree)); - span.setAttribute(cons_span::attr::convergePercent, static_cast(convergePercent_)); - span.setAttribute(cons_span::attr::haveCloseTimeConsensus, haveCloseTimeConsensus_); + span.setAttribute(consensus::span::attr::agreeCount, static_cast(agree)); + span.setAttribute(consensus::span::attr::disagreeCount, static_cast(disagree)); span.setAttribute( - cons_span::attr::thresholdPercent, + consensus::span::attr::convergePercent, static_cast(convergePercent_)); + span.setAttribute(consensus::span::attr::haveCloseTimeConsensus, haveCloseTimeConsensus_); + span.setAttribute( + consensus::span::attr::thresholdPercent, static_cast(adaptor_.parms().avCT_CONSENSUS_PCT)); char const* stateStr = "no"; @@ -1812,7 +1817,7 @@ Consensus::haveConsensus(std::unique_ptr 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::startEstablishTracing() telemetry::SpanGuard::span( telemetry::TraceCategory::Consensus, telemetry::seg::consensus, - telemetry::cons_span::op::establish)); + telemetry::consensus::span::op::establish)); } template @@ -1955,11 +1960,12 @@ Consensus::updateEstablishTracing() if (!establishSpan_) return; establishSpan_->setAttribute( - telemetry::cons_span::attr::convergePercent, static_cast(convergePercent_)); + telemetry::consensus::span::attr::convergePercent, static_cast(convergePercent_)); establishSpan_->setAttribute( - telemetry::cons_span::attr::establishCount, static_cast(establishCounter_)); + telemetry::consensus::span::attr::establishCount, static_cast(establishCounter_)); establishSpan_->setAttribute( - telemetry::cons_span::attr::proposers, static_cast(currPeerPositions_.size())); + telemetry::consensus::span::attr::proposers, + static_cast(currPeerPositions_.size())); } template diff --git a/src/xrpld/consensus/ConsensusSpanNames.h b/src/xrpld/consensus/ConsensusSpanNames.h index d10a48c86e..ed4c23d363 100644 --- a/src/xrpld/consensus/ConsensusSpanNames.h +++ b/src/xrpld/consensus/ConsensusSpanNames.h @@ -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 -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 `_` 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 diff --git a/src/xrpld/overlay/detail/PeerImp.cpp b/src/xrpld/overlay/detail/PeerImp.cpp index 3e8190b862..9faae9c83a 100644 --- a/src/xrpld/overlay/detail/PeerImp.cpp +++ b/src/xrpld/overlay/detail/PeerImp.cpp @@ -1,6 +1,5 @@ #include -#include #include #include #include @@ -1980,8 +1979,9 @@ PeerImp::onMessage(std::shared_ptr 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::proposalReceiveSpan(set)); - span->setAttribute(telemetry::cons_span::attr::trusted, isTrusted); - span->setAttribute(telemetry::cons_span::attr::round, static_cast(set.proposeseq())); + span->setAttribute(telemetry::consensus::span::attr::trusted, isTrusted); + span->setAttribute( + telemetry::consensus::span::attr::round, static_cast(set.proposeseq())); std::weak_ptr const weak = shared_from_this(); app_.getJobQueue().addJob( @@ -2565,11 +2565,11 @@ PeerImp::onMessage(std::shared_ptr 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::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(val->getFieldU32(sfLedgerSequence))); }