GetCounts.cpp

#include <xrpld/app/ledger/InboundLedgers.h>
#include <xrpld/app/ledger/LedgerMaster.h>
#include <xrpld/app/main/Application.h>
#include <xrpld/app/rdb/backend/SQLiteDatabase.h>
#include <xrpld/rpc/Context.h>
 
#include <xrpl/basics/UptimeClock.h>
#include <xrpl/json/json_forwards.h>
#include <xrpl/json/json_value.h>
#include <xrpl/nodestore/Database.h>
#include <xrpl/protocol/jss.h>
#include <xrpl/server/NetworkOPs.h>
 
#include <chrono>
#include <cstddef>
#include <string>
 
namespace xrpl {
 
static void
textTime(
    std::string& text,
    UptimeClock::time_point& seconds,
    char const* unitName,
    std::chrono::seconds unitVal)
{
    auto i = seconds.time_since_epoch() / unitVal;
 
    if (i == 0)
        return;
 
    seconds -= unitVal * i;
 
    if (!text.empty())
        text += ", ";
 
    text += std::to_string(i);
    text += " ";
    text += unitName;
 
    if (i > 1)
        text += "s";
}
 
json::Value
getCountsJson(Application& app, int minObjectCount)
{
    auto objectCounts = CountedObjects::getInstance().getCounts(minObjectCount);
 
    json::Value ret(json::ValueType::Object);
 
    for (auto const& [k, v] : objectCounts)
    {
        ret[k] = v;
    }
 
    if (app.config().useTxTables())
    {
        auto& db = app.getRelationalDatabase();
 
        auto dbKB = db.getKBUsedAll();
 
        if (dbKB > 0)
            ret[jss::dbKBTotal] = dbKB;
 
        dbKB = db.getKBUsedLedger();
 
        if (dbKB > 0)
            ret[jss::dbKBLedger] = dbKB;
 
        dbKB = db.getKBUsedTransaction();
 
        if (dbKB > 0)
            ret[jss::dbKBTransaction] = dbKB;
 
        {
            std::size_t const c = app.getOPs().getLocalTxCount();
            if (c > 0)
                ret[jss::local_txs] = static_cast<json::UInt>(c);
        }
    }
 
    ret[jss::write_load] = app.getNodeStore().getWriteLoad();
 
    ret[jss::historical_perminute] = static_cast<int>(app.getInboundLedgers().fetchRate());
    ret[jss::SLE_hit_rate] = app.getCachedSLEs().rate();
    ret[jss::ledger_hit_rate] = app.getLedgerMaster().getCacheHitRate();
    ret[jss::AL_size] = json::UInt(app.getAcceptedLedgerCache().size());
    ret[jss::AL_hit_rate] = app.getAcceptedLedgerCache().getHitRate();
 
    ret[jss::fullbelow_size] = static_cast<int>(app.getNodeFamily().getFullBelowCache()->size());
    ret[jss::treenode_cache_size] = app.getNodeFamily().getTreeNodeCache()->getCacheSize();
    ret[jss::treenode_track_size] = app.getNodeFamily().getTreeNodeCache()->getTrackSize();
 
    std::string uptime;
    auto s = UptimeClock::now();
    using namespace std::chrono_literals;
    textTime(uptime, s, "year", 365 * 24h);
    textTime(uptime, s, "day", 24h);
    textTime(uptime, s, "hour", 1h);
    textTime(uptime, s, "minute", 1min);
    textTime(uptime, s, "second", 1s);
    ret[jss::uptime] = uptime;
 
    app.getNodeStore().getCountsJson(ret);
 
    return ret;
}
 
// {
//   min_count: <number>  // optional, defaults to 10
// }
json::Value
doGetCounts(rpc::JsonContext& context)
{
    int minCount = 10;
 
    if (context.params.isMember(jss::min_count))
        minCount = context.params[jss::min_count].asUInt();
 
    return getCountsJson(context.app, minCount);
}
 
}  // namespace xrpl