PerfLog.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2018 Ripple Labs Inc.
 
    Permission to use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#ifndef RIPPLE_BASICS_PERFLOG_H
#define RIPPLE_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,
    const std::string& actionDescription,
    std::chrono::duration<Rep, Period> maxDelay,
    const beast::Journal& 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  // RIPPLE_BASICS_PERFLOG_H