Logger.hpp

#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;
struct LogFileRotationTests;
 
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 struct ::LogFileRotationTests;
    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 RotationParams {
        uint32_t sizeMB;
        uint32_t maxFiles;
    };
 
    struct FileLoggingParams {
        std::string logDir;
        std::optional<RotationParams> rotation;  
    };
 
    friend struct ::BenchmarkLoggingInitializer;
 
    [[nodiscard]]
    static std::shared_ptr<spdlog::sinks::sink>
    createFileSink(FileLoggingParams const& params, std::string const& format);
};
 
};  // namespace util