log_router.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/logger/interfaces/log_filter_interface.h>
#include <kcenon/logger/interfaces/log_entry.h>
#include <kcenon/common/interfaces/logger_interface.h>
#include <string>
#include <vector>
#include <unordered_map>
#include <memory>
#include <regex>
 
namespace kcenon::logger::routing {
 
// Type alias for log_level
using log_level = common::interfaces::log_level;
 
struct route_config {
    std::vector<std::string> writer_names;
    std::unique_ptr<log_filter_interface> filter;
    bool stop_propagation = false;
 
    route_config() = default;
    route_config(route_config&&) = default;
    route_config& operator=(route_config&&) = default;
};
 
class log_router {
private:
    std::vector<route_config> routes_;
    bool exclusive_routes_ = false;
 
public:
    void add_route(route_config config) {
        routes_.push_back(std::move(config));
    }
 
    void set_exclusive_routes(bool exclusive) {
        exclusive_routes_ = exclusive;
    }
 
    void clear_routes() {
        routes_.clear();
    }
 
    std::vector<std::string> get_writers_for_log(const log_entry& entry) const {
        std::vector<std::string> writers;
 
        for (const auto& route : routes_) {
            if (route.filter && route.filter->should_log(entry)) {
                writers.insert(writers.end(), route.writer_names.begin(), route.writer_names.end());
                if (route.stop_propagation) {
                    break;
                }
            }
        }
 
        return writers;
    }
 
    bool is_exclusive_routing() const {
        return exclusive_routes_;
    }
};
 
class router_builder {
private:
    log_router& router_;
    route_config config_;
 
public:
    explicit router_builder(log_router& router) : router_(router) {}
 
    router_builder& when_level(log_level level) {
        config_.filter = std::make_unique<class level_condition>(level);
        return *this;
    }
 
    router_builder& when_matches(const std::string& pattern) {
        config_.filter = std::make_unique<class regex_condition>(pattern);
        return *this;
    }
 
    router_builder& route_to(const std::string& writer_name, bool stop_propagation = false) {
        config_.writer_names.push_back(writer_name);
        config_.stop_propagation = stop_propagation;
        router_.add_route(std::move(config_));
        return *this;
    }
 
    router_builder& route_to(const std::vector<std::string>& writer_names, bool stop_propagation = false) {
        config_.writer_names = writer_names;
        config_.stop_propagation = stop_propagation;
        router_.add_route(std::move(config_));
        return *this;
    }
 
private:
    class level_condition : public log_filter_interface {
    private:
        log_level target_level_;
    public:
        explicit level_condition(log_level level) : target_level_(level) {}
 
        bool should_log(const log_entry& entry) const override {
            return entry.level == target_level_;
        }
 
        std::string get_name() const override {
            return "level_condition";
        }
    };
 
    class regex_condition : public log_filter_interface {
    private:
        std::regex pattern_;
    public:
        explicit regex_condition(const std::string& pattern) : pattern_(pattern) {}
 
        bool should_log(const log_entry& entry) const override {
            // Use implicit conversion to string_view
            std::string_view msg_view = entry.message;
            return std::regex_search(msg_view.begin(), msg_view.end(), pattern_);
        }
 
        std::string get_name() const override {
            return "regex_condition";
        }
    };
};
 
} // namespace kcenon::logger::routing