Logger.hpp

//------------------------------------------------------------------------------
/*
    This file is part of clio: https://github.com/XRPLF/clio
    Copyright (c) 2022, the clio developers.
 
    Permission to use, copy, modify, and 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.
*/
//==============================================================================
 
#pragma once
 
#include "util/SourceLocation.hpp"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <expected>
#include <memory>
#include <sstream>
#include <string>
#include <vector>
 
// We forward declare spdlog::logger and spdlog::sinks::sink
// to avoid including the spdlog headers in this header file.
namespace spdlog {
 
class logger;  // NOLINT(readability-identifier-naming)
 
namespace sinks {
class sink;  // NOLINT(readability-identifier-naming)
}  // namespace sinks
 
}  // namespace spdlog
 
struct BenchmarkLoggingInitializer;
 
namespace util {
 
namespace config {
class ClioConfigDefinition;
}  // namespace config
 
#ifndef COVERAGE_ENABLED
#define LOG(x)                                   \
    if (auto clio_pump__ = x; not clio_pump__) { \
    } else                                       \
        clio_pump__
#else
#define LOG(x) x
#endif
 
enum class Severity {
    TRC,
    DBG,
    NFO,
    WRN,
    ERR,
    FTL,
};
 
class Logger final {
    std::shared_ptr<spdlog::logger> logger_;
 
    friend class LogService;  // to expose the Pump interface
    friend struct ::BenchmarkLoggingInitializer;
 
    class Pump final {
        std::shared_ptr<spdlog::logger> logger_;
        Severity const severity_;
        SourceLocationType const sourceLocation_;
        std::ostringstream stream_;
        bool const enabled_;
 
    public:
        ~Pump();
 
        Pump(std::shared_ptr<spdlog::logger> logger, Severity sev, SourceLocationType const& loc);
 
        Pump(Pump&&) = delete;
        Pump(Pump const&) = delete;
        Pump&
        operator=(Pump const&) = delete;
        Pump&
        operator=(Pump&&) = delete;
 
        template <typename T>
        [[maybe_unused]] Pump&
        operator<<(T&& data)
        {
            if (enabled_)
                stream_ << std::forward<T>(data);
            return *this;
        }
 
        operator bool() const
        {
            return enabled_;
        }
    };
 
public:
    static constexpr std::array<char const*, 8> kCHANNELS = {
        "General",
        "WebServer",
        "Backend",
        "RPC",
        "ETL",
        "Subscriptions",
        "Performance",
        "Migration",
    };
 
    Logger(std::string channel);
 
    Logger(Logger const&) = default;
    ~Logger() = default;
 
    Logger(Logger&&) = default;
    Logger&
    operator=(Logger const&) = default;
 
    Logger&
    operator=(Logger&&) = default;
 
    [[nodiscard]] Pump
    trace(SourceLocationType const& loc = CURRENT_SRC_LOCATION) const;
 
    [[nodiscard]] Pump
    debug(SourceLocationType const& loc = CURRENT_SRC_LOCATION) const;
 
    [[nodiscard]] Pump
    info(SourceLocationType const& loc = CURRENT_SRC_LOCATION) const;
 
    [[nodiscard]] Pump
    warn(SourceLocationType const& loc = CURRENT_SRC_LOCATION) const;
 
    [[nodiscard]] Pump
    error(SourceLocationType const& loc = CURRENT_SRC_LOCATION) const;
 
    [[nodiscard]] Pump
    fatal(SourceLocationType const& loc = CURRENT_SRC_LOCATION) const;
 
private:
    Logger(std::shared_ptr<spdlog::logger> logger);
};
 
class LogService {
    struct Data {
        bool isAsync;
        Severity defaultSeverity;
        std::vector<std::shared_ptr<spdlog::sinks::sink>> allSinks;
    };
 
    friend class Logger;
 
private:
    static Data data;
 
    static std::shared_ptr<spdlog::logger>
    registerLogger(std::string const& channel, Severity severity = data.defaultSeverity);
 
public:
    LogService() = delete;
 
    [[nodiscard]] static std::expected<void, std::string>
    init(config::ClioConfigDefinition const& config);
 
    static void
    shutdown();
 
    [[nodiscard]] static Logger::Pump
    trace(SourceLocationType const& loc = CURRENT_SRC_LOCATION);
 
    [[nodiscard]] static Logger::Pump
    debug(SourceLocationType const& loc = CURRENT_SRC_LOCATION);
 
    [[nodiscard]] static Logger::Pump
    info(SourceLocationType const& loc = CURRENT_SRC_LOCATION);
 
    [[nodiscard]] static Logger::Pump
    warn(SourceLocationType const& loc = CURRENT_SRC_LOCATION);
 
    [[nodiscard]] static Logger::Pump
    error(SourceLocationType const& loc = CURRENT_SRC_LOCATION);
 
    [[nodiscard]] static Logger::Pump
    fatal(SourceLocationType const& loc = CURRENT_SRC_LOCATION);
 
    [[nodiscard]] static bool
    enabled();
 
private:
    struct FileLoggingParams {
        std::string logDir;
 
        uint32_t rotationSizeMB;
        uint32_t dirMaxFiles;
    };
 
    friend struct ::BenchmarkLoggingInitializer;
 
    [[nodiscard]]
    static std::shared_ptr<spdlog::sinks::sink>
    createFileSink(FileLoggingParams const& params, std::string const& format);
};
 
};  // namespace util