Counters.hpp

#pragma once
 
#include "rpc/WorkQueue.hpp"
#include "util/prometheus/Counter.hpp"
#include "util/prometheus/Histogram.hpp"
 
#include <boost/json.hpp>
#include <boost/json/object.hpp>
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <mutex>
#include <string>
#include <unordered_map>
 
namespace rpc {

class Counters {
    using CounterType = std::reference_wrapper<util::prometheus::CounterInt>;
    struct MethodInfo {
        MethodInfo(std::string const& method);
 
        CounterType started;
        CounterType finished;
        CounterType failed;
        CounterType errored;
        CounterType forwarded;
        CounterType failedForward;
        CounterType duration;
    };
 
    MethodInfo&
    getMethodInfo(std::string const& method);
 
    mutable std::mutex mutex_;
    std::unordered_map<std::string, MethodInfo> methodInfo_;
 
    // counters that don't carry RPC method information
    CounterType tooBusyCounter_;
    CounterType notReadyCounter_;
    CounterType badSyntaxCounter_;
    CounterType unknownCommandCounter_;
    CounterType internalErrorCounter_;
 
    std::reference_wrapper<util::prometheus::HistogramInt> ledgerAgeLedgersHistogram_;
    CounterType ledgerHashRequestsCounter_;
 
    std::reference_wrapper<Reportable const> workQueue_;
    std::chrono::time_point<std::chrono::system_clock> startupTime_;
 
public:
    Counters(Reportable const& wq);

    static Counters
    makeCounters(WorkQueue const& wq)
    {
        return Counters{wq};
    }

    void
    rpcFailed(std::string const& method);

    void
    rpcErrored(std::string const& method);

    void
    rpcComplete(std::string const& method, std::chrono::microseconds const& rpcDuration);

    void
    rpcForwarded(std::string const& method);

    void
    rpcFailedToForward(std::string const& method);

    void
    onTooBusy();

    void
    onNotReady();

    void
    onBadSyntax();

    void
    onUnknownCommand();

    void
    onInternalError();

    void
    recordLedgerRequest(boost::json::object const& params, std::uint32_t currentLedgerSequence);

    std::chrono::seconds
    uptime() const;

    boost::json::object
    report() const;
};
 
}  // namespace rpc