log_filter.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 <algorithm>
#include <regex>
#include <functional>
 
namespace kcenon::logger::filters {
 
// Type alias for log_level
using log_level = common::interfaces::log_level;
 
class level_filter : public log_filter_interface {
private:
    log_level min_level_;
 
public:
    explicit level_filter(log_level min_level) : min_level_(min_level) {}
 
    bool should_log(const log_entry& entry) const override {
        return static_cast<int>(entry.level) >= static_cast<int>(min_level_);
    }
 
    std::string get_name() const override {
        return "level_filter";
    }
};
 
class exact_level_filter : public log_filter_interface {
private:
    log_level level_;
 
public:
    explicit exact_level_filter(log_level level) : level_(level) {}
 
    bool should_log(const log_entry& entry) const override {
        return entry.level == level_;
    }
 
    std::string get_name() const override {
        return "exact_level_filter";
    }
};
 
class regex_filter : public log_filter_interface {
private:
    std::regex pattern_;
    bool include_matches_;
 
public:
    regex_filter(const std::string& pattern, bool include_matches = true)
        : pattern_(pattern), include_matches_(include_matches) {}
 
    bool should_log(const log_entry& entry) const override {
        bool matches = std::regex_search(entry.message.to_string(), pattern_);
        return include_matches_ ? matches : !matches;
    }
 
    std::string get_name() const override {
        return "regex_filter";
    }
};
 
class composite_filter : public log_filter_interface {
public:
    enum class logic_type { AND, OR };
 
private:
    std::vector<std::unique_ptr<log_filter_interface>> filters_;
    logic_type logic_;
 
public:
    explicit composite_filter(logic_type logic) : logic_(logic) {}
 
    void add_filter(std::unique_ptr<log_filter_interface> filter) {
        filters_.push_back(std::move(filter));
    }
 
    bool should_log(const log_entry& entry) const override {
        if (filters_.empty()) return true;
 
        if (logic_ == logic_type::AND) {
            for (const auto& filter : filters_) {
                if (!filter->should_log(entry)) {
                    return false;
                }
            }
            return true;
        } else { // OR logic
            for (const auto& filter : filters_) {
                if (filter->should_log(entry)) {
                    return true;
                }
            }
            return false;
        }
    }
 
    std::string get_name() const override {
        return logic_ == logic_type::AND ? "composite_and_filter" : "composite_or_filter";
    }
};
 
class function_filter : public log_filter_interface {
private:
    std::function<bool(const log_entry&)> predicate_;
 
public:
    explicit function_filter(decltype(predicate_) predicate) : predicate_(std::move(predicate)) {}
 
    bool should_log(const log_entry& entry) const override {
        return predicate_(entry);
    }
 
    std::string get_name() const override {
        return "function_filter";
    }
};
 
class field_exists_filter : public log_filter_interface {
private:
    std::string field_name_;
    bool require_exists_;
 
public:
    explicit field_exists_filter(const std::string& field_name, bool require_exists = true)
        : field_name_(field_name), require_exists_(require_exists) {}
 
    bool should_log(const log_entry& entry) const override {
        bool has_field = entry.fields.has_value() &&
                         entry.fields->find(field_name_) != entry.fields->end();
        return require_exists_ ? has_field : !has_field;
    }
 
    std::string get_name() const override {
        return "field_exists_filter";
    }
};
 
class field_value_filter : public log_filter_interface {
private:
    std::string field_name_;
    log_value expected_value_;
    bool negate_;
 
public:
    field_value_filter(const std::string& field_name, log_value expected_value, bool negate = false)
        : field_name_(field_name), expected_value_(std::move(expected_value)), negate_(negate) {}
 
    bool should_log(const log_entry& entry) const override {
        if (!entry.fields.has_value()) {
            return negate_;  // No fields: pass if negating
        }
 
        auto it = entry.fields->find(field_name_);
        if (it == entry.fields->end()) {
            return negate_;  // Field not found: pass if negating
        }
 
        bool matches = it->second == expected_value_;
        return negate_ ? !matches : matches;
    }
 
    std::string get_name() const override {
        return "field_value_filter";
    }
};
 
class field_range_filter : public log_filter_interface {
private:
    std::string field_name_;
    double min_value_;
    double max_value_;
    bool inclusive_min_;
    bool inclusive_max_;
 
public:
    field_range_filter(const std::string& field_name,
                       double min_value,
                       double max_value,
                       bool inclusive_min = true,
                       bool inclusive_max = true)
        : field_name_(field_name)
        , min_value_(min_value)
        , max_value_(max_value)
        , inclusive_min_(inclusive_min)
        , inclusive_max_(inclusive_max) {}
 
    bool should_log(const log_entry& entry) const override {
        if (!entry.fields.has_value()) {
            return false;
        }
 
        auto it = entry.fields->find(field_name_);
        if (it == entry.fields->end()) {
            return false;
        }
 
        // Extract numeric value
        double value = 0.0;
        if (std::holds_alternative<int64_t>(it->second)) {
            value = static_cast<double>(std::get<int64_t>(it->second));
        } else if (std::holds_alternative<double>(it->second)) {
            value = std::get<double>(it->second);
        } else {
            return false;  // Not a numeric field
        }
 
        // Check range
        bool above_min = inclusive_min_ ? (value >= min_value_) : (value > min_value_);
        bool below_max = inclusive_max_ ? (value <= max_value_) : (value < max_value_);
        return above_min && below_max;
    }
 
    std::string get_name() const override {
        return "field_range_filter";
    }
};
 
class field_regex_filter : public log_filter_interface {
private:
    std::string field_name_;
    std::regex pattern_;
    bool include_matches_;
 
public:
    field_regex_filter(const std::string& field_name,
                       const std::string& pattern,
                       bool include_matches = true)
        : field_name_(field_name)
        , pattern_(pattern)
        , include_matches_(include_matches) {}
 
    bool should_log(const log_entry& entry) const override {
        if (!entry.fields.has_value()) {
            return !include_matches_;
        }
 
        auto it = entry.fields->find(field_name_);
        if (it == entry.fields->end()) {
            return !include_matches_;
        }
 
        // Only works on string fields
        if (!std::holds_alternative<std::string>(it->second)) {
            return !include_matches_;
        }
 
        const auto& str_value = std::get<std::string>(it->second);
        bool matches = std::regex_search(str_value, pattern_);
        return include_matches_ ? matches : !matches;
    }
 
    std::string get_name() const override {
        return "field_regex_filter";
    }
};
 
class category_filter : public log_filter_interface {
private:
    std::vector<std::string> categories_;
    bool include_;
 
public:
    category_filter(std::vector<std::string> categories, bool include = true)
        : categories_(std::move(categories)), include_(include) {}
 
    bool should_log(const log_entry& entry) const override {
        if (!entry.category.has_value()) {
            return !include_;  // No category: pass if excluding
        }
 
        std::string cat = entry.category->to_string();
        bool found = std::find(categories_.begin(), categories_.end(), cat) != categories_.end();
        return include_ ? found : !found;
    }
 
    std::string get_name() const override {
        return "category_filter";
    }
};
 
} // namespace kcenon::logger::filters