registry_audit_log.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 "../utils/source_location.h"
 
#include <atomic>
#include <chrono>
#include <mutex>
#include <string>
#include <vector>
 
namespace kcenon::common {
namespace interfaces {
 
// Use project's source_location for C++17 compatibility
using source_location = kcenon::common::source_location;
 
enum class registry_action {
    register_logger,      
    unregister_logger,    
    set_default_logger,   
    register_factory,     
    set_default_factory,  
    clear_loggers,        
    freeze_logger_registry,  
    register_service,     
    unregister_service,   
    clear_services,       
    freeze_service_container  
};
 
inline const char* to_string(registry_action action) {
    switch (action) {
        case registry_action::register_logger: return "register_logger";
        case registry_action::unregister_logger: return "unregister_logger";
        case registry_action::set_default_logger: return "set_default_logger";
        case registry_action::register_factory: return "register_factory";
        case registry_action::set_default_factory: return "set_default_factory";
        case registry_action::clear_loggers: return "clear_loggers";
        case registry_action::freeze_logger_registry: return "freeze_logger_registry";
        case registry_action::register_service: return "register_service";
        case registry_action::unregister_service: return "unregister_service";
        case registry_action::clear_services: return "clear_services";
        case registry_action::freeze_service_container: return "freeze_service_container";
        default: return "unknown";
    }
}
 
struct registry_event {
    registry_action action;
 
    std::string target_name;
 
    std::string file;
 
    int line;
 
    std::string function;
 
    std::chrono::system_clock::time_point timestamp;
 
    bool success;
 
    std::string error_message;
 
    registry_event(
        registry_action act,
        std::string target,
        const source_location& loc = source_location::current(),
        bool succeeded = true,
        std::string error = "")
        : action(act)
        , target_name(std::move(target))
        , file(loc.file_name())
        , line(static_cast<int>(loc.line()))
        , function(loc.function_name())
        , timestamp(std::chrono::system_clock::now())
        , success(succeeded)
        , error_message(std::move(error)) {}
};
 
class RegistryAuditLog {
public:
    static void log_event(const registry_event& event);
 
    static void log_event(registry_event&& event);
 
    static std::vector<registry_event> get_events();
 
    static std::vector<registry_event> get_events_by_action(registry_action action);
 
    static std::vector<registry_event> get_events_in_range(
        std::chrono::system_clock::time_point start,
        std::chrono::system_clock::time_point end);
 
    static size_t event_count();
 
    static bool is_enabled();
 
    static void set_enabled(bool enabled);
 
    static void clear();
 
private:
    RegistryAuditLog() = delete;
 
    static std::mutex& get_mutex();
    static std::vector<registry_event>& get_events_internal();
    static std::atomic<bool>& get_enabled_flag();
};
 
// ============================================================================
// RegistryAuditLog Implementation
// ============================================================================
 
inline std::mutex& RegistryAuditLog::get_mutex() {
    static std::mutex mutex;
    return mutex;
}
 
inline std::vector<registry_event>& RegistryAuditLog::get_events_internal() {
    static std::vector<registry_event> events;
    return events;
}
 
inline std::atomic<bool>& RegistryAuditLog::get_enabled_flag() {
    static std::atomic<bool> enabled{true};
    return enabled;
}
 
inline void RegistryAuditLog::log_event(const registry_event& event) {
    if (!is_enabled()) {
        return;
    }
 
    std::lock_guard<std::mutex> lock(get_mutex());
    get_events_internal().push_back(event);
}
 
inline void RegistryAuditLog::log_event(registry_event&& event) {
    if (!is_enabled()) {
        return;
    }
 
    std::lock_guard<std::mutex> lock(get_mutex());
    get_events_internal().push_back(std::move(event));
}
 
inline std::vector<registry_event> RegistryAuditLog::get_events() {
    std::lock_guard<std::mutex> lock(get_mutex());
    return get_events_internal();
}
 
inline std::vector<registry_event> RegistryAuditLog::get_events_by_action(
    registry_action action) {
    std::lock_guard<std::mutex> lock(get_mutex());
 
    std::vector<registry_event> result;
    for (const auto& event : get_events_internal()) {
        if (event.action == action) {
            result.push_back(event);
        }
    }
    return result;
}
 
inline std::vector<registry_event> RegistryAuditLog::get_events_in_range(
    std::chrono::system_clock::time_point start,
    std::chrono::system_clock::time_point end) {
    std::lock_guard<std::mutex> lock(get_mutex());
 
    std::vector<registry_event> result;
    for (const auto& event : get_events_internal()) {
        if (event.timestamp >= start && event.timestamp <= end) {
            result.push_back(event);
        }
    }
    return result;
}
 
inline size_t RegistryAuditLog::event_count() {
    std::lock_guard<std::mutex> lock(get_mutex());
    return get_events_internal().size();
}
 
inline bool RegistryAuditLog::is_enabled() {
    return get_enabled_flag().load(std::memory_order_acquire);
}
 
inline void RegistryAuditLog::set_enabled(bool enabled) {
    get_enabled_flag().store(enabled, std::memory_order_release);
}
 
inline void RegistryAuditLog::clear() {
    std::lock_guard<std::mutex> lock(get_mutex());
    get_events_internal().clear();
}
 
} // namespace interfaces
} // namespace kcenon::common