PerfLog.h

#pragma once
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/StringUtilities.h>
#include <xrpl/core/Job.h>
#include <xrpl/json/json_value.h>
 
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <functional>
#include <memory>
#include <span>
#include <string_view>
 
namespace beast {
class Journal;
}  // namespace beast
 
namespace xrpl {
class Application;
class Section;
namespace perf {

 
class PerfLog
{
public:
    using SteadyClock = std::chrono::steady_clock;
    using SystemClock = std::chrono::system_clock;
    using SteadyTimePoint = std::chrono::time_point<SteadyClock>;
    using SystemTimePoint = std::chrono::time_point<SystemClock>;
    using Seconds = std::chrono::seconds;
    using Milliseconds = std::chrono::milliseconds;
    using Microseconds = std::chrono::microseconds;

    struct Setup
    {
        std::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_view method, std::uint64_t requestId) = 0;

    virtual void
    rpcFinish(std::string_view method, std::uint64_t requestId) = 0;

    virtual void
    rpcError(std::string_view method, std::uint64_t requestId) = 0;

    virtual void
    jobQueue(JobType const type) = 0;

    virtual void
    jobStart(JobType const type, Microseconds dur, SteadyTimePoint startTime, int instance) = 0;

    virtual void
    jobFinish(JobType const type, Microseconds dur, int instance) = 0;

    [[nodiscard]] virtual json::Value
    countersJson() const = 0;

    [[nodiscard]] virtual json::Value
    currentJson() const = 0;

    virtual void
    resizeJobs(int const resize) = 0;

    virtual void
    rotate() = 0;
};
 
PerfLog::Setup
setupPerfLog(Section const& section, std::filesystem::path const& configDir);

std::unique_ptr<PerfLog>
makePerfLog(
    PerfLog::Setup const& setup,
    Application& app,
    std::span<NullTerminatedView const> methodNames,
    beast::Journal journal,
    std::function<void()>&& signalStop);
 
template <typename Func, class Rep, class Period>
auto
measureDurationAndLog(
    Func&& func,
    std::string_view actionDescription,
    std::chrono::duration<Rep, Period> maxDelay,
    beast::Journal const& journal)
{
    auto startTime = std::chrono::high_resolution_clock::now();
 
    auto result = func();
 
    auto endTime = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(endTime - startTime);
    if (duration > maxDelay)
    {
        JLOG(journal.warn()) << actionDescription << " took " << duration.count() << " ms";
    }
 
    return result;
}
 
}  // namespace perf
}  // namespace xrpl