filter_factory.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <memory>
#include <string>
#include <unordered_map>
#include <functional>
 
#include "../interfaces/log_filter_interface.h"
#include "../filters/log_filter.h"
#include "../interfaces/log_entry.h"
 
namespace kcenon::logger {
 
class filter_factory {
public:
    using creator_fn = std::function<std::unique_ptr<log_filter_interface>()>;
 
    //========================================================================
    // Static Factory Methods
    //========================================================================
 
    static std::unique_ptr<log_filter_interface> create_level(
        log_level min_level
    ) {
        return std::make_unique<filters::level_filter>(min_level);
    }
 
    static std::unique_ptr<log_filter_interface> create_regex(
        const std::string& pattern,
        bool include_matches = true
    ) {
        return std::make_unique<filters::regex_filter>(pattern, include_matches);
    }
 
    static std::unique_ptr<log_filter_interface> create_function(
        std::function<bool(const log_entry&)> predicate
    ) {
        return std::make_unique<filters::function_filter>(std::move(predicate));
    }
 
    static std::unique_ptr<filters::composite_filter> create_composite_and() {
        return std::make_unique<filters::composite_filter>(
            filters::composite_filter::logic_type::AND
        );
    }
 
    static std::unique_ptr<filters::composite_filter> create_composite_or() {
        return std::make_unique<filters::composite_filter>(
            filters::composite_filter::logic_type::OR
        );
    }
 
    //========================================================================
    // Preset Factory Methods
    //========================================================================
 
    static std::unique_ptr<log_filter_interface> create_development() {
        return create_level(log_level::trace);
    }
 
    static std::unique_ptr<log_filter_interface> create_production() {
        auto composite = create_composite_and();
        composite->add_filter(create_level(log_level::warning));
        composite->add_filter(create_regex("password|secret|token|api.?key", false));
        return composite;
    }
 
    static std::unique_ptr<log_filter_interface> create_errors_only() {
        return create_level(log_level::error);
    }
 
    static std::unique_ptr<log_filter_interface> create_component_filter(
        const std::string& component
    ) {
        return create_regex("\\[" + component + "\\]", true);
    }
 
    static std::unique_ptr<log_filter_interface> create_sensitive_filter() {
        return create_regex(
            "password|secret|token|api.?key|credential|auth|bearer",
            false  // Exclude matches
        );
    }
 
    //========================================================================
    // Builder Pattern Helper
    //========================================================================
 
    class builder {
    public:
        builder& with_min_level(log_level level) {
            filters_.push_back(create_level(level));
            return *this;
        }
 
        builder& include_pattern(const std::string& pattern) {
            filters_.push_back(create_regex(pattern, true));
            return *this;
        }
 
        builder& exclude_pattern(const std::string& pattern) {
            filters_.push_back(create_regex(pattern, false));
            return *this;
        }
 
        builder& with_predicate(std::function<bool(const log_entry&)> pred) {
            filters_.push_back(create_function(std::move(pred)));
            return *this;
        }
 
        std::unique_ptr<log_filter_interface> build() {
            if (filters_.empty()) {
                return nullptr;
            }
            if (filters_.size() == 1) {
                return std::move(filters_[0]);
            }
 
            auto composite = create_composite_and();
            for (auto& filter : filters_) {
                composite->add_filter(std::move(filter));
            }
            return composite;
        }
 
    private:
        std::vector<std::unique_ptr<log_filter_interface>> filters_;
    };
 
    static builder create_builder() {
        return builder{};
    }
 
    //========================================================================
    // Registry Pattern
    //========================================================================
 
    static void register_type(const std::string& name, creator_fn creator) {
        registry()[name] = std::move(creator);
    }
 
    static std::unique_ptr<log_filter_interface> create(const std::string& name) {
        auto it = registry().find(name);
        if (it == registry().end()) {
            return nullptr;
        }
        return it->second();
    }
 
    static bool has_type(const std::string& name) {
        return registry().find(name) != registry().end();
    }
 
private:
    static std::unordered_map<std::string, creator_fn>& registry() {
        static std::unordered_map<std::string, creator_fn> instance;
        return instance;
    }
};
 
} // namespace kcenon::logger