logger.h

Go to the documentation of this file.

/*
 * Copyright 2023 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
// IWYU pragma: no_include <asio/ip/basic_endpoint.hpp>
// IWYU pragma: no_include <asio/local/basic_endpoint.hpp>
// IWYU pragma: no_include <asio/ip/detail/impl/endpoint.ipp>
// IWYU pragma: no_include <catch2/catch_message.hpp>
 
#include <iterator>
#include <memory>
#include <string_view>
#include <utility>
 
#include <fmt/base.h>
#include <fmt/format.h>
 
#include "msgpack_rpc/config/logging_config.h"
#include "msgpack_rpc/logging/i_log_sink.h"
#include "msgpack_rpc/logging/log_level.h"
#include "msgpack_rpc/logging/log_sinks.h"
#include "msgpack_rpc/logging/source_location_view.h"
 
namespace msgpack_rpc::logging {

class Logger {
public:
    [[nodiscard]] static std::shared_ptr<Logger> create(
        const config::LoggingConfig& config = config::LoggingConfig()) {
        return create(
            create_log_sink_from_config(config), config.output_log_level());
    }

    [[nodiscard]] static std::shared_ptr<Logger> create(
        std::shared_ptr<ILogSink> sink,
        LogLevel output_log_level = LogLevel::INFO) {
        return std::make_shared<Logger>(std::move(sink), output_log_level);
    }

    Logger(std::shared_ptr<ILogSink> sink, LogLevel output_log_level)
        : sink_(std::move(sink)), output_log_level_(output_log_level) {}

    template <typename Body>
    void write(SourceLocationView location, LogLevel level, Body&& body) {
        if (sink_) {
            sink_->write(location, level,
                // NOLINTNEXTLINE
                std::string_view(std::forward<Body>(body)));
        }
    }

    template <typename... Args>
    void write(SourceLocationView location, LogLevel level,
        fmt::format_string<Args...> format, Args&&... args) {
        if (sink_) {
            fmt::memory_buffer buffer;
            fmt::format_to(std::back_inserter(buffer), format,
                std::forward<Args>(args)...);
            sink_->write(location, level,
                std::string_view(buffer.data(), buffer.size()));
        }
    }

    [[nodiscard]] LogLevel output_log_level() const noexcept {
        return output_log_level_;
    }
 
private:
    std::shared_ptr<ILogSink> sink_;

    LogLevel output_log_level_;
};
 
}  // namespace msgpack_rpc::logging

#define MSGPACK_RPC_LOG(LOGGER_PTR, LEVEL, ...)                       \
    do {                                                              \
        if (LEVEL >= (LOGGER_PTR)->output_log_level()) {              \
            (LOGGER_PTR)                                              \
                ->write(MSGPACK_RPC_CURRENT_SOURCE_LOCATION(), LEVEL, \
                    __VA_ARGS__);                                     \
        }                                                             \
    } while (false)

#define MSGPACK_RPC_TRACE(LOGGER_PTR, ...) \
    MSGPACK_RPC_LOG(                       \
        LOGGER_PTR, ::msgpack_rpc::logging::LogLevel::TRACE, __VA_ARGS__)

#define MSGPACK_RPC_DEBUG(LOGGER_PTR, ...) \
    MSGPACK_RPC_LOG(                       \
        LOGGER_PTR, ::msgpack_rpc::logging::LogLevel::DEBUG, __VA_ARGS__)

#define MSGPACK_RPC_INFO(LOGGER_PTR, ...) \
    MSGPACK_RPC_LOG(                      \
        LOGGER_PTR, ::msgpack_rpc::logging::LogLevel::INFO, __VA_ARGS__)

#define MSGPACK_RPC_WARN(LOGGER_PTR, ...) \
    MSGPACK_RPC_LOG(                      \
        LOGGER_PTR, ::msgpack_rpc::logging::LogLevel::WARN, __VA_ARGS__)

#define MSGPACK_RPC_ERROR(LOGGER_PTR, ...) \
    MSGPACK_RPC_LOG(                       \
        LOGGER_PTR, ::msgpack_rpc::logging::LogLevel::ERROR, __VA_ARGS__)

#define MSGPACK_RPC_CRITICAL(LOGGER_PTR, ...) \
    MSGPACK_RPC_LOG(                          \
        LOGGER_PTR, ::msgpack_rpc::logging::LogLevel::CRITICAL, __VA_ARGS__)