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 <optional>
#include <sstream>
#include <string>
#include <string_view>
#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;
class LoggerFixture;
struct LogServiceInitTests;
 
namespace util {
 
namespace impl {
class OnAssert;
}  // namespace impl
 
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 {
    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<std::string_view, 8> kCHANNELS = {
        "General",
        "WebServer",
        "Backend",
        "RPC",
        "ETL",
        "Subscriptions",
        "Performance",
        "Migration",
    };

    Logger(std::string_view const channel);
 
    Logger(Logger const&) = default;
    ~Logger();
 
    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 LogServiceState {
protected:
    friend struct ::LogServiceInitTests;
    friend class ::LoggerFixture;
    friend class Logger;
    friend class ::util::impl::OnAssert;

    static void
    init(bool isAsync, Severity defaultSeverity, std::vector<std::shared_ptr<spdlog::sinks::sink>> const& sinks);

    [[nodiscard]] static bool
    initialized();

    [[nodiscard]] static bool
    hasSinks();

    static void
    reset();

    static void
    replaceSinks(std::vector<std::shared_ptr<spdlog::sinks::sink>> const& sinks);

    static std::shared_ptr<spdlog::logger>
    registerLogger(std::string_view channel, std::optional<Severity> severity = std::nullopt);
 
protected:
    static bool isAsync_;                                             // NOLINT(readability-identifier-naming)
    static Severity defaultSeverity_;                                 // NOLINT(readability-identifier-naming)
    static std::vector<std::shared_ptr<spdlog::sinks::sink>> sinks_;  // NOLINT(readability-identifier-naming)
    static bool initialized_;                                         // NOLINT(readability-identifier-naming)
};

class LogService : public LogServiceState {
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);
 
private:
    [[nodiscard]] static std::expected<std::vector<std::shared_ptr<spdlog::sinks::sink>>, std::string>
    getSinks(config::ClioConfigDefinition const& config);
 
    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