logger.h

Go to the documentation of this file.

/*
 * Copyright 2022 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
 
#include <algorithm>
#include <iterator>
#include <string>
#include <string_view>
#include <utility>
 
#include <fmt/base.h>
#include <fmt/format.h>
 
#include "num_collect/logging/impl/iteration_layer_handler.h"
#include "num_collect/logging/log_config.h"
#include "num_collect/logging/log_level.h"
#include "num_collect/logging/log_tag.h"
#include "num_collect/logging/log_tag_config.h"
#include "num_collect/logging/log_tag_view.h"
#include "num_collect/logging/sinks/log_sink.h"
#include "num_collect/logging/time_stamp.h"
#include "num_collect/util/source_info_view.h"
 
namespace num_collect::logging {
 
class logging_proxy {
public:
    logging_proxy(std::string_view tag, log_level level,
        util::source_info_view source, const sinks::log_sink* sink,
        bool write_log) noexcept
        : tag_(tag),
          level_(level),
          source_(source),
          sink_(sink),
          write_log_(write_log) {}
 
    void operator()(std::string_view body) const {
        if (!write_log_) {
            return;
        }
 
        sink_->write(time_stamp::now(), tag_, level_, source_, body);
    }
 
    template <typename... Args>
        requires(sizeof...(Args) > 0)
    void operator()(fmt::format_string<Args...> format, Args&&... args) const {
        if (!write_log_) {
            return;
        }
 
        fmt::memory_buffer buffer;
        fmt::format_to(
            std::back_inserter(buffer), format, std::forward<Args>(args)...);
        sink_->write(time_stamp::now(), tag_, level_, source_,
            std::string_view{buffer.data(), buffer.size()});
    }
 
private:
    std::string_view tag_;
 
    log_level level_;
 
    util::source_info_view source_;
 
    const sinks::log_sink* sink_;
 
    bool write_log_;
};
 
constexpr auto default_tag = log_tag_view("");
 
class logger {
public:
    logger() : logger(default_tag) {}
 
    explicit logger(log_tag_view tag) : logger(tag, get_config_of(tag)) {}
 
    logger(log_tag_view tag, log_tag_config config)
        : logger(static_cast<log_tag>(tag), std::move(config)) {}
 
    logger(log_tag tag, log_tag_config config)
        : tag_(std::move(tag)),
          config_(std::move(config)),
          always_output_log_level_(std::max(config_.output_log_level(),
              config_.output_log_level_in_child_iterations())),
          lowest_output_log_level_(std::min(config_.output_log_level(),
              config_.output_log_level_in_child_iterations())) {}
 
    [[nodiscard]] auto tag() const noexcept -> const log_tag& { return tag_; }
 
    [[nodiscard]] auto config() const noexcept -> const log_tag_config& {
        return config_;
    }
 
    void set_iterative() const noexcept {
        iteration_layer_handler_.set_iterative();
    }
 
    void initialize_child_algorithm_logger(logger& child) noexcept {
        iteration_layer_handler_.initialize_lower_layer(
            child.iteration_layer_handler_);
    }
 
    [[nodiscard]] auto should_log(log_level level) const noexcept -> bool {
        if (level < lowest_output_log_level_) {
            return false;
        }
        if (level >= always_output_log_level_) {
            return true;
        }
        if (iteration_layer_handler_.is_upper_layer_iterative()) {
            return level >= config_.output_log_level_in_child_iterations();
        }
        return level >= config_.output_log_level();
    }
 
    [[nodiscard]] auto log(log_level level,
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return logging_proxy(
            tag_.name(), level, source, &config_.sink(), should_log(level));
    }
 
    [[nodiscard]] auto trace(
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return log(log_level::trace, source);
    }
 
    [[nodiscard]] auto debug(
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return log(log_level::debug, source);
    }
 
    [[nodiscard]] auto iteration(
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return log(log_level::iteration, source);
    }
 
    [[nodiscard]] auto iteration_label(
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return log(log_level::iteration_label, source);
    }
 
    [[nodiscard]] auto summary(
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return log(log_level::summary, source);
    }
 
    [[nodiscard]] auto info(
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return log(log_level::info, source);
    }
 
    [[nodiscard]] auto warning(
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return log(log_level::warning, source);
    }
 
    [[nodiscard]] auto error(
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return log(log_level::error, source);
    }
 
    [[nodiscard]] auto critical(
        util::source_info_view source = util::source_info_view()) const noexcept
        -> logging_proxy {
        return log(log_level::critical, source);
    }
 
    void log_without_condition_check(util::source_info_view source,
        log_level level, std::string_view body) const {
        config_.sink().write(
            time_stamp::now(), tag_.name(), level, source, body);
    }
 
    template <typename... Args>
        requires(sizeof...(Args) > 0)
    void log_without_condition_check(util::source_info_view source,
        log_level level, fmt::format_string<Args...> format,
        Args&&... args) const {
        fmt::memory_buffer buffer;
        fmt::format_to(
            std::back_inserter(buffer), format, std::forward<Args>(args)...);
        config_.sink().write(time_stamp::now(), tag_.name(), level, source,
            std::string_view(buffer.data(), buffer.size()));
    }
 
private:
    log_tag tag_;
 
    log_tag_config config_;
 
    log_level always_output_log_level_;
 
    log_level lowest_output_log_level_;
 
    impl::iteration_layer_handler iteration_layer_handler_{};
};
 
}  // namespace num_collect::logging