PerfLog.h

#ifndef XRPL_BASICS_PERFLOG_H
#define XRPL_BASICS_PERFLOG_H
 
#include <xrpld/core/Config.h>
#include <xrpld/core/JobTypes.h>
 
#include <xrpl/json/json_value.h>
 
#include <boost/filesystem.hpp>
 
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
 
namespace beast {
class Journal;
}
 
namespace ripple {
class Application;
namespace perf {
 
class PerfLog
{
public:
    using steady_clock = std::chrono::steady_clock;
    using system_clock = std::chrono::system_clock;
    using steady_time_point = std::chrono::time_point<steady_clock>;
    using system_time_point = std::chrono::time_point<system_clock>;
    using seconds = std::chrono::seconds;
    using milliseconds = std::chrono::milliseconds;
    using microseconds = std::chrono::microseconds;
 
    struct Setup
    {
        boost::filesystem::path perfLog;
        // log_interval is in milliseconds to support faster testing.
        milliseconds logInterval{seconds(1)};
    };
 
    virtual ~PerfLog() = default;
 
    virtual void
    start()
    {
    }
 
    virtual void
    stop()
    {
    }
 
    virtual void
    rpcStart(std::string const& method, std::uint64_t requestId) = 0;
 
    virtual void
    rpcFinish(std::string const& method, std::uint64_t requestId) = 0;
 
    virtual void
    rpcError(std::string const& method, std::uint64_t requestId) = 0;
 
    virtual void
    jobQueue(JobType const type) = 0;
 
    virtual void
    jobStart(
        JobType const type,
        microseconds dur,
        steady_time_point startTime,
        int instance) = 0;
 
    virtual void
    jobFinish(JobType const type, microseconds dur, int instance) = 0;
 
    virtual Json::Value
    countersJson() const = 0;
 
    virtual Json::Value
    currentJson() const = 0;
 
    virtual void
    resizeJobs(int const resize) = 0;
 
    virtual void
    rotate() = 0;
};
 
PerfLog::Setup
setup_PerfLog(Section const& section, boost::filesystem::path const& configDir);
 
std::unique_ptr<PerfLog>
make_PerfLog(
    PerfLog::Setup const& setup,
    Application& app,
    beast::Journal journal,
    std::function<void()>&& signalStop);
 
template <typename Func, class Rep, class Period>
auto
measureDurationAndLog(
    Func&& func,
    std::string const& actionDescription,
    std::chrono::duration<Rep, Period> maxDelay,
    beast::Journal const& journal)
{
    auto start_time = std::chrono::high_resolution_clock::now();
 
    auto result = func();
 
    auto end_time = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(
        end_time - start_time);
    if (duration > maxDelay)
    {
        JLOG(journal.warn())
            << actionDescription << " took " << duration.count() << " ms";
    }
 
    return result;
}
 
}  // namespace perf
}  // namespace ripple
 
#endif  // XRPL_BASICS_PERFLOG_H