Log.h

#pragma once
 
#include <xrpl/beast/utility/Journal.h>
 
#include <boost/beast/core/string.hpp>
 
#include <filesystem>
#include <fstream>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
#include <utility>
#include <vector>
 
namespace xrpl {

class Logs
{
private:
    class Sink : public beast::Journal::Sink
    {
    private:
        Logs& logs_;
        std::string partition_;
 
    public:
        Sink(std::string partition, beast::Severity thresh, Logs& logs);
 
        Sink(Sink const&) = delete;
        Sink&
        operator=(Sink const&) = delete;
 
        void
        write(beast::Severity level, std::string const& text) override;
 
        void
        writeAlways(beast::Severity level, std::string const& text) override;
    };

    class File
    {
    public:
        File();

        ~File() = default;

        [[nodiscard]] bool
        isOpen() const noexcept;

        bool
        open(std::filesystem::path const& path);

        bool
        closeAndReopen();

        void
        close();

        void
        write(char const* text);

        void
        writeln(char const* text);

        void
        write(std::string const& str)
        {
            write(str.c_str());
        }
 
        void
        writeln(std::string const& str)
        {
            writeln(str.c_str());
        }

 
    private:
        std::unique_ptr<std::ofstream> stream_;
        std::filesystem::path path_;
    };
 
    std::mutex mutable mutex_;
    std::map<std::string, std::unique_ptr<beast::Journal::Sink>, boost::beast::iless> sinks_;
    beast::Severity thresh_;
    File file_;
    bool silent_ = false;
 
public:
    Logs(beast::Severity level);
 
    Logs(Logs const&) = delete;
    Logs&
    operator=(Logs const&) = delete;
 
    virtual ~Logs() = default;
 
    bool
    open(std::filesystem::path const& pathToLogFile);
 
    beast::Journal::Sink&
    get(std::string const& name);
 
    beast::Journal::Sink&
    operator[](std::string const& name);
 
    beast::Journal
    journal(std::string const& name);
 
    beast::Severity
    threshold() const;
 
    void
    threshold(beast::Severity thresh);
 
    std::vector<std::pair<std::string, std::string>>
    partitionSeverities() const;
 
    void
    write(
        beast::Severity level,
        std::string const& partition,
        std::string const& text,
        bool console);
 
    std::string
    rotate();

    void
    silent(bool bSilent)
    {
        silent_ = bSilent;
    }
 
    virtual std::unique_ptr<beast::Journal::Sink>
    makeSink(std::string const& partition, beast::Severity startingLevel);
 
public:
    static std::string
    toString(beast::Severity s);
 
    static std::optional<beast::Severity>
    fromString(std::string const& s);
 
private:
    // Maximum line length for log messages.
    // If the message exceeds this length it will be truncated with ellipses.
    static constexpr auto kMaximumMessageCharacters = 12 * 1024;
 
    static void
    format(
        std::string& output,
        std::string const& message,
        beast::Severity severity,
        std::string const& partition);
};
 
// Wraps a Journal::Stream to skip evaluation of
// expensive argument lists if the stream is not active.
#ifndef JLOG
#define JLOG(x) \
    if (!(x))   \
        ;       \
    else        \
        x
#endif
 
#ifndef CLOG
#define CLOG(ss) \
    if (!(ss))   \
        ;        \
    else         \
        *ss
#endif
 
//------------------------------------------------------------------------------
// Debug logging:

std::unique_ptr<beast::Journal::Sink>
setDebugLogSink(std::unique_ptr<beast::Journal::Sink> sink);

beast::Journal
debugLog();
 
}  // namespace xrpl