Include context on calls to InboundLedgers::acquire

ximinez · ximinez · commit 0efb3187deaa · 2025-02-11T12:18:01.000-05:00
diff --git a/src/test/app/LedgerReplay_test.cpp b/src/test/app/LedgerReplay_test.cpp
@@ -92,8 +92,11 @@ class MagicInboundLedgers : public InboundLedgers
     virtual ~MagicInboundLedgers() = default;
 
     virtual std::shared_ptr<Ledger const>
-    acquire(uint256 const& hash, std::uint32_t seq, InboundLedger::Reason)
-        override
+    acquire(
+        uint256 const& hash,
+        std::uint32_t seq,
+        InboundLedger::Reason,
+        const char*) override
     {
         if (bhvr == InboundLedgersBehavior::DropAll)
             return {};
diff --git a/src/xrpld/app/ledger/InboundLedgers.h b/src/xrpld/app/ledger/InboundLedgers.h
@@ -41,7 +41,11 @@ class InboundLedgers
     // Callers should use this if they possibly need an authoritative
     // response immediately.
     virtual std::shared_ptr<Ledger const>
-    acquire(uint256 const& hash, std::uint32_t seq, InboundLedger::Reason) = 0;
+    acquire(
+        uint256 const& hash,
+        std::uint32_t seq,
+        InboundLedger::Reason,
+        const char* context) = 0;
 
     // Callers should use this if they are known to be executing on the Job
     // Queue. TODO review whether all callers of acquire() can use this
diff --git a/src/xrpld/app/ledger/detail/InboundLedgers.cpp b/src/xrpld/app/ledger/detail/InboundLedgers.cpp
@@ -70,7 +70,8 @@ class InboundLedgersImp : public InboundLedgers
     acquire(
         uint256 const& hash,
         std::uint32_t seq,
-        InboundLedger::Reason reason) override
+        InboundLedger::Reason reason,
+        const char* context) override
     {
         auto doAcquire = [&, seq, reason]() -> std::shared_ptr<Ledger const> {
             XRPL_ASSERT(
@@ -92,7 +93,7 @@ class InboundLedgersImp : public InboundLedgers
             ss << "InboundLedger::acquire: "
                << "Request: " << to_string(hash) << ", " << seq
                << " NeedNetworkLedger: " << (needNetworkLedger ? "yes" : "no")
-               << " Reason: " << to_string(reason)
+               << " Reason: " << to_string(reason) << " Context: " << context
                << " Should acquire: " << (shouldAcquire ? "true." : "false.");
 
             /*  Acquiring ledgers is somewhat expensive. It requires lots of
@@ -222,7 +223,7 @@ class InboundLedgersImp : public InboundLedgers
         {
             try
             {
-                acquire(hash, seq, reason);
+                acquire(hash, seq, reason, "acquireAsync");
             }
             catch (std::exception const& e)
             {
diff --git a/src/xrpld/app/ledger/detail/LedgerCleaner.cpp b/src/xrpld/app/ledger/detail/LedgerCleaner.cpp
@@ -255,7 +255,8 @@ class LedgerCleanerImp : public LedgerCleaner
             app_.getInboundLedgers().acquire(
                 ledger->info().hash,
                 ledger->info().seq,
-                InboundLedger::Reason::GENERIC);
+                InboundLedger::Reason::GENERIC,
+                "getLedgerHash");
         }
         return hash ? *hash : beast::zero;  // kludge
     }
@@ -275,13 +276,19 @@ class LedgerCleanerImp : public LedgerCleaner
         bool doTxns)
     {
         auto nodeLedger = app_.getInboundLedgers().acquire(
-            ledgerHash, ledgerIndex, InboundLedger::Reason::GENERIC);
+            ledgerHash,
+            ledgerIndex,
+            InboundLedger::Reason::GENERIC,
+            "doLedger");
         if (!nodeLedger)
         {
             JLOG(j_.debug()) << "Ledger " << ledgerIndex << " not available";
             app_.getLedgerMaster().clearLedger(ledgerIndex);
             app_.getInboundLedgers().acquire(
-                ledgerHash, ledgerIndex, InboundLedger::Reason::GENERIC);
+                ledgerHash,
+                ledgerIndex,
+                InboundLedger::Reason::GENERIC,
+                "doLedger not available");
             return false;
         }
 
@@ -307,7 +314,10 @@ class LedgerCleanerImp : public LedgerCleaner
             JLOG(j_.debug()) << "Ledger " << ledgerIndex << " is missing nodes";
             app_.getLedgerMaster().clearLedger(ledgerIndex);
             app_.getInboundLedgers().acquire(
-                ledgerHash, ledgerIndex, InboundLedger::Reason::GENERIC);
+                ledgerHash,
+                ledgerIndex,
+                InboundLedger::Reason::GENERIC,
+                "doLedger missing nodes");
             return false;
         }
 
@@ -363,7 +373,10 @@ class LedgerCleanerImp : public LedgerCleaner
                     // We found the hash and sequence of a better reference
                     // ledger.
                     referenceLedger = app_.getInboundLedgers().acquire(
-                        refHash, refIndex, InboundLedger::Reason::GENERIC);
+                        refHash,
+                        refIndex,
+                        InboundLedger::Reason::GENERIC,
+                        "getHash");
                     if (referenceLedger)
                         ledgerHash =
                             getLedgerHash(referenceLedger, ledgerIndex);
diff --git a/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp b/src/xrpld/app/ledger/detail/LedgerDeltaAcquire.cpp
@@ -110,7 +110,10 @@ LedgerDeltaAcquire::trigger(std::size_t limit, ScopedLockType& sl)
 
     if (fallBack_)
         inboundLedgers_.acquire(
-            hash_, ledgerSeq_, InboundLedger::Reason::GENERIC);
+            hash_,
+            ledgerSeq_,
+            InboundLedger::Reason::GENERIC,
+            "LedgerDeltaAcquire::trigger");
 }
 
 void
diff --git a/src/xrpld/app/ledger/detail/LedgerMaster.cpp b/src/xrpld/app/ledger/detail/LedgerMaster.cpp
@@ -879,7 +879,8 @@ void
 LedgerMaster::failedSave(std::uint32_t seq, uint256 const& hash)
 {
     clearLedger(seq);
-    app_.getInboundLedgers().acquire(hash, seq, InboundLedger::Reason::GENERIC);
+    app_.getInboundLedgers().acquire(
+        hash, seq, InboundLedger::Reason::GENERIC, "failedSave");
 }
 
 // Check if the specified ledger can become the new last fully-validated
@@ -927,7 +928,7 @@ LedgerMaster::checkAccept(uint256 const& hash, std::uint32_t seq)
         // FIXME: We may not want to fetch a ledger with just one
         // trusted validation
         ledger = app_.getInboundLedgers().acquire(
-            hash, seq, InboundLedger::Reason::GENERIC);
+            hash, seq, InboundLedger::Reason::GENERIC, "checkAccept");
     }
 
     if (ledger)
@@ -1302,7 +1303,10 @@ LedgerMaster::findNewLedgersToPublish(
                 // Can we try to acquire the ledger we need?
                 if (!ledger && (++acqCount < ledger_fetch_size_))
                     ledger = app_.getInboundLedgers().acquire(
-                        *hash, seq, InboundLedger::Reason::GENERIC);
+                        *hash,
+                        seq,
+                        InboundLedger::Reason::GENERIC,
+                        "findNewLedgersToPublish");
             }
 
             // Did we acquire the next ledger we need to publish?
@@ -1493,15 +1497,17 @@ LedgerMaster::updatePaths()
                 app_.getInboundLedgers().acquire(
                     lastLedger->info().parentHash,
                     lastLedger->info().seq - 1,
-                    InboundLedger::Reason::GENERIC);
+                    InboundLedger::Reason::GENERIC,
+                    "updatePaths open");
             }
             else
             {
                 // this ledger is the problem
                 app_.getInboundLedgers().acquire(
                     lastLedger->info().hash,
                     lastLedger->info().seq,
-                    InboundLedger::Reason::GENERIC);
+                    InboundLedger::Reason::GENERIC,
+                    "updatePaths closed");
             }
         }
     }
@@ -1702,7 +1708,7 @@ LedgerMaster::walkHashBySeq(
         if (!ledger)
         {
             if (auto const l = app_.getInboundLedgers().acquire(
-                    *refHash, refIndex, reason))
+                    *refHash, refIndex, reason, "walkHashBySeq"))
             {
                 ledgerHash = hashOfSeq(*l, index, m_journal);
                 XRPL_ASSERT(
@@ -1828,8 +1834,8 @@ LedgerMaster::fetchForHistory(
         {
             if (!app_.getInboundLedgers().isFailure(*hash))
             {
-                ledger =
-                    app_.getInboundLedgers().acquire(*hash, missing, reason);
+                ledger = app_.getInboundLedgers().acquire(
+                    *hash, missing, reason, "fetchForHistory");
                 if (!ledger && missing != fetch_seq_ &&
                     missing > app_.getNodeStore().earliestLedgerSeq())
                 {
@@ -1896,7 +1902,8 @@ LedgerMaster::fetchForHistory(
                             h->isNonZero(),
                             "ripple::LedgerMaster::fetchForHistory : "
                             "prefetched ledger");
-                        app_.getInboundLedgers().acquire(*h, seq, reason);
+                        app_.getInboundLedgers().acquire(
+                            *h, seq, reason, "fetchForHistory no ledger");
                     }
                 }
             }
diff --git a/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp b/src/xrpld/app/ledger/detail/LedgerReplayTask.cpp
@@ -162,7 +162,8 @@ LedgerReplayTask::trigger(ScopedLockType& sl)
             parent_ = inboundLedgers_.acquire(
                 parameter_.startHash_,
                 parameter_.startSeq_,
-                InboundLedger::Reason::GENERIC);
+                InboundLedger::Reason::GENERIC,
+                "LedgerReplayTask::trigger");
         }
         if (parent_)
         {
diff --git a/src/xrpld/app/ledger/detail/SkipListAcquire.cpp b/src/xrpld/app/ledger/detail/SkipListAcquire.cpp
@@ -109,7 +109,11 @@ SkipListAcquire::trigger(std::size_t limit, ScopedLockType& sl)
     }
 
     if (fallBack_)
-        inboundLedgers_.acquire(hash_, 0, InboundLedger::Reason::GENERIC);
+        inboundLedgers_.acquire(
+            hash_,
+            0,
+            InboundLedger::Reason::GENERIC,
+            "SkipListAcquire::trigger");
 }
 
 void
diff --git a/src/xrpld/app/misc/NetworkOPs.cpp b/src/xrpld/app/misc/NetworkOPs.cpp
@@ -1728,7 +1728,10 @@ NetworkOPsImp::checkLastClosedLedger(
 
     if (!consensus)
         consensus = app_.getInboundLedgers().acquire(
-            closedLedger, 0, InboundLedger::Reason::CONSENSUS);
+            closedLedger,
+            0,
+            InboundLedger::Reason::CONSENSUS,
+            "checkLastClosedLedger");
 
     if (consensus &&
         (!m_ledgerMaster.canBeCurrent(consensus) ||
diff --git a/src/xrpld/rpc/detail/RPCHelpers.cpp b/src/xrpld/rpc/detail/RPCHelpers.cpp
@@ -1087,7 +1087,10 @@ getLedgerByContext(RPC::JsonContext& context)
                 // ledger they want. Try to get it.
 
                 if (auto il = context.app.getInboundLedgers().acquire(
-                        *refHash, refIndex, InboundLedger::Reason::GENERIC))
+                        *refHash,
+                        refIndex,
+                        InboundLedger::Reason::GENERIC,
+                        "getLedgerByContext no hash"))
                 {
                     Json::Value jvResult = RPC::make_error(
                         rpcLGR_NOT_FOUND,
@@ -1121,7 +1124,10 @@ getLedgerByContext(RPC::JsonContext& context)
     // Try to get the desired ledger
     // Verify all nodes even if we think we have it
     auto ledger = context.app.getInboundLedgers().acquire(
-        ledgerHash, ledgerIndex, InboundLedger::Reason::GENERIC);
+        ledgerHash,
+        ledgerIndex,
+        InboundLedger::Reason::GENERIC,
+        "getLedgerByContext");
 
     // In standalone mode, accept the ledger from the ledger cache
     if (!ledger && context.app.config().standalone())
diff --git a/src/xrpld/shamap/detail/NodeFamily.cpp b/src/xrpld/shamap/detail/NodeFamily.cpp
@@ -102,7 +102,7 @@ NodeFamily::acquire(uint256 const& hash, std::uint32_t seq)
         JLOG(j_.error()) << "Missing node in " << to_string(hash);
 
         app_.getInboundLedgers().acquire(
-            hash, seq, InboundLedger::Reason::GENERIC);
+            hash, seq, InboundLedger::Reason::GENERIC, "NodeFamily::acquire");
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,8 @@ class InboundLedgersImp : public InboundLedgers`
`70`	`70`	`acquire(`
`71`	`71`	`uint256 const& hash,`
`72`	`72`	`std::uint32_t seq,`
`73`		`- InboundLedger::Reason reason) override`
	`73`	`+ InboundLedger::Reason reason,`
	`74`	`+ const char* context) override`
`74`	`75`	`{`
`75`	`76`	`auto doAcquire = [&, seq, reason]() -> std::shared_ptr<Ledger const> {`
`76`	`77`	`XRPL_ASSERT(`
`@@ -92,7 +93,7 @@ class InboundLedgersImp : public InboundLedgers`
`92`	`93`	`ss << "InboundLedger::acquire: "`
`93`	`94`	`<< "Request: " << to_string(hash) << ", " << seq`
`94`	`95`	`<< " NeedNetworkLedger: " << (needNetworkLedger ? "yes" : "no")`
`95`		`- << " Reason: " << to_string(reason)`
	`96`	`+ << " Reason: " << to_string(reason) << " Context: " << context`
`96`	`97`	`<< " Should acquire: " << (shouldAcquire ? "true." : "false.");`
`97`	`98`
`98`	`99`	`/* Acquiring ledgers is somewhat expensive. It requires lots of`
`@@ -222,7 +223,7 @@ class InboundLedgersImp : public InboundLedgers`
`222`	`223`	`{`
`223`	`224`	`try`
`224`	`225`	`{`
`225`		`- acquire(hash, seq, reason);`
	`226`	`+ acquire(hash, seq, reason, "acquireAsync");`
`226`	`227`	`}`
`227`	`228`	`catch (std::exception const& e)`
`228`	`229`	`{`
Original file line number	Diff line number	Diff line change
`@@ -879,7 +879,8 @@ void`
`879`	`879`	`LedgerMaster::failedSave(std::uint32_t seq, uint256 const& hash)`
`880`	`880`	`{`
`881`	`881`	`clearLedger(seq);`
`882`		`- app_.getInboundLedgers().acquire(hash, seq, InboundLedger::Reason::GENERIC);`
	`882`	`+ app_.getInboundLedgers().acquire(`
	`883`	`+ hash, seq, InboundLedger::Reason::GENERIC, "failedSave");`
`883`	`884`	`}`
`884`	`885`
`885`	`886`	`// Check if the specified ledger can become the new last fully-validated`
`@@ -927,7 +928,7 @@ LedgerMaster::checkAccept(uint256 const& hash, std::uint32_t seq)`
`927`	`928`	`// FIXME: We may not want to fetch a ledger with just one`
`928`	`929`	`// trusted validation`
`929`	`930`	`ledger = app_.getInboundLedgers().acquire(`
`930`		`- hash, seq, InboundLedger::Reason::GENERIC);`
	`931`	`+ hash, seq, InboundLedger::Reason::GENERIC, "checkAccept");`
`931`	`932`	`}`
`932`	`933`
`933`	`934`	`if (ledger)`
`@@ -1302,7 +1303,10 @@ LedgerMaster::findNewLedgersToPublish(`
`1302`	`1303`	`// Can we try to acquire the ledger we need?`
`1303`	`1304`	`if (!ledger && (++acqCount < ledger_fetch_size_))`
`1304`	`1305`	`ledger = app_.getInboundLedgers().acquire(`
`1305`		`- *hash, seq, InboundLedger::Reason::GENERIC);`
	`1306`	`+ *hash,`
	`1307`	`+ seq,`
	`1308`	`+ InboundLedger::Reason::GENERIC,`
	`1309`	`+ "findNewLedgersToPublish");`
`1306`	`1310`	`}`
`1307`	`1311`
`1308`	`1312`	`// Did we acquire the next ledger we need to publish?`
`@@ -1493,15 +1497,17 @@ LedgerMaster::updatePaths()`
`1493`	`1497`	`app_.getInboundLedgers().acquire(`
`1494`	`1498`	`lastLedger->info().parentHash,`
`1495`	`1499`	`lastLedger->info().seq - 1,`
`1496`		`- InboundLedger::Reason::GENERIC);`
	`1500`	`+ InboundLedger::Reason::GENERIC,`
	`1501`	`+ "updatePaths open");`
`1497`	`1502`	`}`
`1498`	`1503`	`else`
`1499`	`1504`	`{`
`1500`	`1505`	`// this ledger is the problem`
`1501`	`1506`	`app_.getInboundLedgers().acquire(`
`1502`	`1507`	`lastLedger->info().hash,`
`1503`	`1508`	`lastLedger->info().seq,`
`1504`		`- InboundLedger::Reason::GENERIC);`
	`1509`	`+ InboundLedger::Reason::GENERIC,`
	`1510`	`+ "updatePaths closed");`
`1505`	`1511`	`}`
`1506`	`1512`	`}`
`1507`	`1513`	`}`
`@@ -1702,7 +1708,7 @@ LedgerMaster::walkHashBySeq(`
`1702`	`1708`	`if (!ledger)`
`1703`	`1709`	`{`
`1704`	`1710`	`if (auto const l = app_.getInboundLedgers().acquire(`
`1705`		`- *refHash, refIndex, reason))`
	`1711`	`+ *refHash, refIndex, reason, "walkHashBySeq"))`
`1706`	`1712`	`{`
`1707`	`1713`	`ledgerHash = hashOfSeq(*l, index, m_journal);`
`1708`	`1714`	`XRPL_ASSERT(`
`@@ -1828,8 +1834,8 @@ LedgerMaster::fetchForHistory(`
`1828`	`1834`	`{`
`1829`	`1835`	`if (!app_.getInboundLedgers().isFailure(*hash))`
`1830`	`1836`	`{`
`1831`		`- ledger =`
`1832`		`- app_.getInboundLedgers().acquire(*hash, missing, reason);`
	`1837`	`+ ledger = app_.getInboundLedgers().acquire(`
	`1838`	`+ *hash, missing, reason, "fetchForHistory");`
`1833`	`1839`	`if (!ledger && missing != fetch_seq_ &&`
`1834`	`1840`	`missing > app_.getNodeStore().earliestLedgerSeq())`
`1835`	`1841`	`{`
`@@ -1896,7 +1902,8 @@ LedgerMaster::fetchForHistory(`
`1896`	`1902`	`h->isNonZero(),`
`1897`	`1903`	`"ripple::LedgerMaster::fetchForHistory : "`
`1898`	`1904`	`"prefetched ledger");`
`1899`		`- app_.getInboundLedgers().acquire(*h, seq, reason);`
	`1905`	`+ app_.getInboundLedgers().acquire(`
	`1906`	`+ *h, seq, reason, "fetchForHistory no ledger");`
`1900`	`1907`	`}`
`1901`	`1908`	`}`
`1902`	`1909`	`}`
Original file line number	Diff line number	Diff line change
`@@ -162,7 +162,8 @@ LedgerReplayTask::trigger(ScopedLockType& sl)`
`162`	`162`	`parent_ = inboundLedgers_.acquire(`
`163`	`163`	`parameter_.startHash_,`
`164`	`164`	`parameter_.startSeq_,`
`165`		`- InboundLedger::Reason::GENERIC);`
	`165`	`+ InboundLedger::Reason::GENERIC,`
	`166`	`+ "LedgerReplayTask::trigger");`
`166`	`167`	`}`
`167`	`168`	`if (parent_)`
`168`	`169`	`{`
Original file line number	Diff line number	Diff line change
`@@ -109,7 +109,11 @@ SkipListAcquire::trigger(std::size_t limit, ScopedLockType& sl)`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`if (fallBack_)`
`112`		`- inboundLedgers_.acquire(hash_, 0, InboundLedger::Reason::GENERIC);`
	`112`	`+ inboundLedgers_.acquire(`
	`113`	`+ hash_,`
	`114`	`+ 0,`
	`115`	`+ InboundLedger::Reason::GENERIC,`
	`116`	`+ "SkipListAcquire::trigger");`
`113`	`117`	`}`
`114`	`118`
`115`	`119`	`void`
Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ NodeFamily::acquire(uint256 const& hash, std::uint32_t seq)`
`102`	`102`	`JLOG(j_.error()) << "Missing node in " << to_string(hash);`
`103`	`103`
`104`	`104`	`app_.getInboundLedgers().acquire(`
`105`		`- hash, seq, InboundLedger::Reason::GENERIC);`
	`105`	`+ hash, seq, InboundLedger::Reason::GENERIC, "NodeFamily::acquire");`
`106`	`106`	`}`
`107`	`107`	`}`
`108`	`108`