Log.h

#pragma once
 
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/beast/utility/Journal.h>
 
#include <boost/beast/core/string.hpp>
#include <boost/filesystem.hpp>
 
#include <fstream>
#include <map>
#include <memory>
#include <mutex>
#include <utility>
 
namespace xrpl {
 
// DEPRECATED use beast::severities::Severity instead
enum LogSeverity {
    lsINVALID = -1,  // used to indicate an invalid severity
    lsTRACE = 0,     // Very low-level progress information, details inside
                     // an operation
    lsDEBUG = 1,     // Function-level progress information, operations
    lsINFO = 2,      // Server-level progress information, major operations
    lsWARNING = 3,   // Conditions that warrant human attention, may indicate
                     // a problem
    lsERROR = 4,     // A condition that indicates a problem
    lsFATAL = 5      // A severe condition that indicates a server problem
};
 
class Logs
{
private:
    class Sink : public beast::Journal::Sink
    {
    private:
        Logs& logs_;
        std::string partition_;
 
    public:
        Sink(std::string const& partition, beast::severities::Severity thresh, Logs& logs);
 
        Sink(Sink const&) = delete;
        Sink&
        operator=(Sink const&) = delete;
 
        void
        write(beast::severities::Severity level, std::string const& text) override;
 
        void
        writeAlways(beast::severities::Severity level, std::string const& text) override;
    };
 
    class File
    {
    public:
        File();
 
        ~File() = default;
 
        bool
        isOpen() const noexcept;
 
        bool
        open(boost::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> m_stream;
        boost::filesystem::path m_path;
    };
 
    std::mutex mutable mutex_;
    std::map<std::string, std::unique_ptr<beast::Journal::Sink>, boost::beast::iless> sinks_;
    beast::severities::Severity thresh_;
    File file_;
    bool silent_ = false;
 
public:
    Logs(beast::severities::Severity level);
 
    Logs(Logs const&) = delete;
    Logs&
    operator=(Logs const&) = delete;
 
    virtual ~Logs() = default;
 
    bool
    open(boost::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::severities::Severity
    threshold() const;
 
    void
    threshold(beast::severities::Severity thresh);
 
    std::vector<std::pair<std::string, std::string>>
    partition_severities() const;
 
    void
    write(beast::severities::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::severities::Severity startingLevel);
 
public:
    static LogSeverity
    fromSeverity(beast::severities::Severity level);
 
    static beast::severities::Severity
    toSeverity(LogSeverity level);
 
    static std::string
    toString(LogSeverity s);
 
    static LogSeverity
    fromString(std::string const& s);
 
private:
    enum {
        // Maximum line length for log messages.
        // If the message exceeds this length it will be truncated with
        // ellipses.
        maximumMessageCharacters = 12 * 1024
    };
 
    static void
    format(
        std::string& output,
        std::string const& message,
        beast::severities::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